dng/NN_in_Trading
1
2
Fork 2
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
NN_in_Trading/Experts/NeuroNet_DNG/NeuroNet_AgentsRL.mqh
DNG f56b206ae2 MomAD
2026-06-18 13:05:27 +03:00

4681 lines
184 KiB
MQL5
Raw Permalink Blame History

#ifndef NEURONET_BUILDING_FACADE
#include "NeuroNet.mqh"
#endif // NEURONET_BUILDING_FACADE
//+------------------------------------------------------------------+
//| Logical method implementations generated from NeuroNet.mqh: AgentsRL
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
CNeuronFQF::CNeuronFQF(void)
{
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
CNeuronFQF::~CNeuronFQF(void)
{
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFQF::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl, uint actions, uint quantiles, uint numInputs, ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, actions, optimization_type, batch))
ReturnFalse;
SetActivationFunction(None);
//---
if(!cFraction.Init(0, myIndex, open_cl, actions * quantiles, optimization, batch))
ReturnFalse;
cFraction.SetActivationFunction(None);
//---
if(!cSoftMax.Init(0, myIndex, open_cl, actions * quantiles, optimization, batch))
ReturnFalse;
cSoftMax.SetHeads(actions);
cSoftMax.SetActivationFunction(None);
//---
if(!cCosine.Init(numInputs, myIndex, open_cl, actions * quantiles, optimization, batch))
ReturnFalse;
cCosine.SetActivationFunction(None);
//---
if(!cCosineEmbeding.Init(0, myIndex, open_cl, numInputs, optimization, batch))
ReturnFalse;
cCosineEmbeding.SetActivationFunction(LReLU);
//---
if(!cQuantile0.Init(4 * actions * quantiles, myIndex, open_cl, numInputs, optimization, batch))
ReturnFalse;
cQuantile0.SetActivationFunction(None);
//---
if(!cQuantile1.Init(actions * quantiles, myIndex, open_cl, 4 * actions * quantiles, optimization, batch))
ReturnFalse;
cQuantile1.SetActivationFunction(LReLU);
//---
if(!cQuantile2.Init(0, myIndex, open_cl, actions * quantiles, optimization, batch))
ReturnFalse;
cQuantile2.SetActivationFunction(None);
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFQF::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!cFraction.FeedForward(NeuronOCL))
ReturnFalse;
if(!cSoftMax.FeedForward(GetPointer(cFraction)))
ReturnFalse;
//---
{
uint global_work_offset[2] = {0, 0};
uint global_work_size[2];
global_work_size[1] = Output.Total();
global_work_size[0] = cSoftMax.Neurons() / global_work_size[1];
setBuffer(def_k_FQF_Cosine, def_k_fqf_cosine_softmax, cSoftMax.getOutputIndex());
setBuffer(def_k_FQF_Cosine, def_k_fqf_cosine_outputs, cCosine.getOutputIndex());
kernelExecute(def_k_FQF_Cosine, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!cCosine.getOutput().BufferRead())
ReturnFalse;
#endif
}
//---
if(!cCosineEmbeding.FeedForward(GetPointer(cCosine)))
ReturnFalse;
//---
if(!ElementMult(NeuronOCL.getOutput(), cCosineEmbeding.getOutput(), cQuantile0.getOutput()))
ReturnFalse;
//---
if(!cQuantile1.FeedForward(GetPointer(cQuantile0)))
ReturnFalse;
//---
if(!cQuantile2.FeedForward(GetPointer(cQuantile1)))
ReturnFalse;
//---
{
uint global_work_offset[1] = {0};
uint global_work_size[1] = { Neurons() };
setBuffer(def_k_FQF_Output, def_k_fqfout_quantiles, cQuantile2.getOutputIndex());
setBuffer(def_k_FQF_Output, def_k_fqfout_delta_taus, cSoftMax.getOutputIndex());
setBuffer(def_k_FQF_Output, def_k_fqfout_output, getOutputIndex());
setArgument(def_k_FQF_Output, def_k_fqfout_total, (int)(cQuantile2.Neurons() / global_work_size[0]));
kernelExecute(def_k_FQF_Output, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!Output.BufferRead())
ReturnFalse;
#endif
}
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFQF::calcInputGradients(CNeuronBaseOCL* NeuronOCL)
{
if(!NeuronOCL || !Gradient || !Output)
ReturnFalse;
//---
{
uint global_work_offset[2] = {0, 0};
uint global_work_size[2] = { cSoftMax.Neurons() / Neurons(), Neurons() };
setBuffer(def_k_FQF_OutputGradient, def_k_fqfoutgr_quantiles, cQuantile2.getOutputIndex());
setBuffer(def_k_FQF_OutputGradient, def_k_fqfoutgr_taus, cSoftMax.getOutputIndex());
setBuffer(def_k_FQF_OutputGradient, def_k_fqfoutgr_output_gr, getGradientIndex());
setBuffer(def_k_FQF_OutputGradient, def_k_fqfoutgr_quantiles_gr, cQuantile2.getGradientIndex());
setBuffer(def_k_FQF_OutputGradient, def_k_fqfoutgr_taus_gr, cSoftMax.getGradientIndex());
kernelExecute(def_k_FQF_OutputGradient, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!cQuantile2.getGradient().BufferRead())
ReturnFalse;
#endif
}
//---
if(!cQuantile1.CalcHiddenGradients(cQuantile2.AsObject()))
ReturnFalse;
if(!cQuantile0.CalcHiddenGradients(cQuantile1.AsObject()))
ReturnFalse;
//---
{
uint global_work_offset[2] = {0, 0};
uint global_work_size[2] = { cCosineEmbeding.Neurons(), 1 };
setBuffer(def_k_FQF_QuantileGradient, def_k_fqfqgr_state_enbeding, NeuronOCL.getOutputIndex());
setBuffer(def_k_FQF_QuantileGradient, def_k_fqfqgr_taus_embedding, cCosineEmbeding.getOutputIndex());
setBuffer(def_k_FQF_QuantileGradient, def_k_fqfqgr_quantiles_gr, cQuantile0.getGradientIndex());
setBuffer(def_k_FQF_QuantileGradient, def_k_fqfqgr_state_gr, NeuronOCL.getGradientIndex());
setBuffer(def_k_FQF_QuantileGradient, def_k_fqfqgr_taus_gr, cCosineEmbeding.getGradientIndex());
kernelExecute(def_k_FQF_QuantileGradient, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!NeuronOCL.getGradient().BufferRead())
ReturnFalse;
#endif
}
//---
if(!cCosineEmbeding.CalcHiddenGradients(cCosine.AsObject()))
ReturnFalse;
//---
{
uint global_work_offset[2] = {0, 0};
uint global_work_size[2] = { cSoftMax.Neurons() / Neurons(), Neurons() };
setBuffer(def_k_FQF_CosineGradient, def_k_fqfcosgr_softmax, cSoftMax.getOutputIndex());
setBuffer(def_k_FQF_CosineGradient, def_k_fqfcosgr_output_gr, cCosine.getGradientIndex());
setBuffer(def_k_FQF_CosineGradient, def_k_fqfcosgr_softmax_gr, cSoftMax.getGradientIndex());
kernelExecute(def_k_FQF_CosineGradient, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!cSoftMax.getGradient().BufferRead())
ReturnFalse;
#endif
}
//---
if(!cFraction.CalcHiddenGradients(cSoftMax.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFQF::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
if(!cFraction.UpdateInputWeights(NeuronOCL))
ReturnFalse;
if(!cCosineEmbeding.UpdateInputWeights(GetPointer(cCosine)))
ReturnFalse;
if(!cQuantile1.UpdateInputWeights(GetPointer(cQuantile0)))
ReturnFalse;
if(!cQuantile2.UpdateInputWeights(GetPointer(cQuantile1)))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFQF::Save(const int file_handle)
{
if(!CNeuronBaseOCL::Save(file_handle))
ReturnFalse;
if(!cFraction.Save(file_handle))
ReturnFalse;
if(!cSoftMax.Save(file_handle))
ReturnFalse;
if(!cCosine.Save(file_handle))
ReturnFalse;
if(!cCosineEmbeding.Save(file_handle))
ReturnFalse;
if(!cQuantile0.Save(file_handle))
ReturnFalse;
if(!cQuantile1.Save(file_handle))
ReturnFalse;
if(!cQuantile2.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFQF::Load(const int file_handle)
{
if(!CNeuronBaseOCL::Load(file_handle))
ReturnFalse;
if(FileReadInteger(file_handle) != cFraction.Type() ||
!cFraction.Load(file_handle))
ReturnFalse;
if(FileReadInteger(file_handle) != cSoftMax.Type() ||
!cSoftMax.Load(file_handle))
ReturnFalse;
if(FileReadInteger(file_handle) != cCosine.Type() ||
!cCosine.Load(file_handle))
ReturnFalse;
if(FileReadInteger(file_handle) != cCosineEmbeding.Type() ||
!cCosineEmbeding.Load(file_handle))
ReturnFalse;
if(FileReadInteger(file_handle) != cQuantile0.Type() ||
!cQuantile0.Load(file_handle))
ReturnFalse;
if(FileReadInteger(file_handle) != cQuantile1.Type() ||
!cQuantile1.Load(file_handle))
ReturnFalse;
if(FileReadInteger(file_handle) != cQuantile2.Type() ||
!cQuantile2.Load(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
CLayerDescription* CNeuronFQF::GetLayerInfo(void)
{
CLayerDescription *result = CNeuronBaseOCL::GetLayerInfo();
if(!result)
return result;
result.window_out = cSoftMax.Neurons() / Neurons();
//---
return result;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronFQF::SetOpenCL(COpenCLMy * obj)
{
CNeuronBaseOCL::SetOpenCL(obj);
cFraction.SetOpenCL(OpenCL);
cSoftMax.SetOpenCL(OpenCL);
cCosine.SetOpenCL(OpenCL);
cCosineEmbeding.SetOpenCL(OpenCL);
cQuantile0.SetOpenCL(OpenCL);
cQuantile1.SetOpenCL(OpenCL);
cQuantile2.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronSoftActorCritic::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl, uint actions, uint quantiles, uint numInputs, ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronFQF::Init(numOutputs, myIndex, open_cl, actions, quantiles, numInputs, optimization_type, batch))
ReturnFalse;
//---
if(!cAlphas.Init(0, 0, OpenCL, actions, numInputs, cQuantile2.Neurons(), optimization_type, batch))
ReturnFalse;
cAlphas.SetActivationFunction(SIGMOID);
//---
if(!cLogProbs.BufferInit(actions, 0) || !cLogProbs.BufferCreate(OpenCL))
ReturnFalse;
//---
if(!cRandomize.BufferInit(actions, 0) || !cRandomize.BufferCreate(OpenCL))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronSoftActorCritic::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!CNeuronFQF::feedForward(NeuronOCL))
ReturnFalse;
if(!cAlphas.FeedForward(GetPointer(cQuantile0), cQuantile2.getOutput()))
ReturnFalse;
//---
int actions = cRandomize.Total();
for(int i = 0; i < actions; i++)
{
float probability = (float)MathRand() / 32767.0f;
cRandomize.Update(i, probability);
}
if(!cRandomize.BufferWrite())
ReturnFalse;
//---
uint global_work_offset[1] = {0};
uint global_work_size[1] = {Neurons()};
setBuffer(def_k_SAC_AlphaLogProbs, def_k_sac_alp_alphas, cAlphas.getOutputIndex())
setBuffer(def_k_SAC_AlphaLogProbs, def_k_sac_alp_log_probs, cLogProbs.GetIndex())
setBuffer(def_k_SAC_AlphaLogProbs, def_k_sac_alp_outputs, getOutputIndex())
setBuffer(def_k_SAC_AlphaLogProbs, def_k_sac_alp_probs, cSoftMax.getOutputIndex())
setBuffer(def_k_SAC_AlphaLogProbs, def_k_sac_alp_quantiles, cQuantile2.getOutputIndex())
setBuffer(def_k_SAC_AlphaLogProbs, def_k_sac_alp_random, cRandomize.GetIndex())
setArgument(def_k_SAC_AlphaLogProbs, def_k_sac_alp_count_quants, (int)(cSoftMax.Neurons() / global_work_size[0]))
setArgument(def_k_SAC_AlphaLogProbs, def_k_sac_alp_activation, (int)activation)
kernelExecute(def_k_SAC_AlphaLogProbs, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!cRandomize.BufferRead())
ReturnFalse;
#endif
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronSoftActorCritic::calcAlphaGradients(CNeuronBaseOCL* NeuronOCL)
{
if(!OpenCL || !NeuronOCL || !NeuronOCL.getGradient() ||
NeuronOCL.getGradientIndex() < 0)
ReturnFalse;
//---
uint global_work_offset[1] = {0};
uint global_work_size[1] = {Neurons()};
setBuffer(def_k_SAC_AlphaGradients, def_k_sac_alg_outputs, cAlphas.getOutputIndex())
setBuffer(def_k_SAC_AlphaGradients, def_k_sac_alg_alphas_grad, cAlphas.getGradientIndex())
setBuffer(def_k_SAC_AlphaGradients, def_k_sac_alg_gradient, NeuronOCL.getGradientIndex())
setBuffer(def_k_SAC_AlphaGradients, def_k_sac_alg_log_probs, cLogProbs.GetIndex())
setArgument(def_k_SAC_AlphaGradients, def_k_sac_alg_activation, (int)cAlphas.Activation())
kernelExecute(def_k_SAC_AlphaGradients, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!cLogProbs.BufferRead())
ReturnFalse;
#endif
//---
return cQuantile0.CalcHiddenGradients((CObject*)GetPointer(cAlphas), cQuantile2.getOutput(), cQuantile2.getGradient());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronSoftActorCritic::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
if(!CNeuronFQF::updateInputWeights(NeuronOCL))
ReturnFalse;
//---
return cAlphas.UpdateInputWeights(cQuantile0.AsObject(), cQuantile2.getOutput());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronSoftActorCritic::WeightsUpdate(CNeuronBaseOCL* source, float tau)
{
if(!CNeuronFQF::WeightsUpdate(source, tau))
ReturnFalse;
CNeuronSoftActorCritic *Source = source;
//---
return cAlphas.WeightsUpdate(GetPointer(Source.cAlphas), tau);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronSoftActorCritic::SetOpenCL(COpenCLMy * obj)
{
CNeuronFQF::SetOpenCL(obj);
cAlphas.SetOpenCL(OpenCL);
if(cLogProbs.Total() != Neurons())
cLogProbs.BufferInit(Neurons(), 0);
cLogProbs.BufferCreate(OpenCL);
if(cRandomize.Total() != Neurons())
cRandomize.BufferInit(Neurons(), 0);
cRandomize.BufferCreate(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronSoftActorCritic::Save(const int file_handle)
{
if(!CNeuronFQF::Save(file_handle))
ReturnFalse;
return cAlphas.Save(file_handle);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronSoftActorCritic::Load(const int file_handle)
{
if(!CNeuronFQF::Load(file_handle))
ReturnFalse;
if(FileReadInteger(file_handle) != cAlphas.Type() ||
!cAlphas.Load(file_handle))
ReturnFalse;
//---
if(cLogProbs.Total() != Neurons())
{
cLogProbs.BufferFree();
if(!cLogProbs.BufferInit(Neurons(), 0) ||
(!!OpenCL && !cLogProbs.BufferCreate(OpenCL)))
ReturnFalse;
}
//---
if(cRandomize.Total() != Neurons())
{
cRandomize.BufferFree();
if(!cRandomize.BufferInit(Neurons(), 0) ||
(!!OpenCL && !cRandomize.BufferCreate(OpenCL)))
ReturnFalse;
}
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronSoftActorCritic::CalcLogProbs(CBufferFloat* buffer)
{
if(!buffer || buffer.Total() < Neurons())
ReturnFalse;
if(buffer.GetIndex() < 0 && !buffer.BufferCreate(OpenCL))
ReturnFalse;
//---
uint global_work_offset[1] = {0};
uint global_work_size[1] = {Neurons()};
setBuffer(def_k_SAC_CalcLogProbs, def_k_sacclp_alphas, cAlphas.getOutputIndex())
setBuffer(def_k_SAC_CalcLogProbs, def_k_sacclp_log_probs, buffer.GetIndex())
setBuffer(def_k_SAC_CalcLogProbs, def_k_sacclp_outputs, buffer.GetIndex())
setBuffer(def_k_SAC_CalcLogProbs, def_k_sacclp_probs, cSoftMax.getOutputIndex())
setBuffer(def_k_SAC_CalcLogProbs, def_k_sacclp_quantiles, cQuantile2.getOutputIndex())
setArgument(def_k_SAC_CalcLogProbs, def_k_sacclp_count_quants, (int)(cSoftMax.Neurons() / global_work_size[0]))
setArgument(def_k_SAC_CalcLogProbs, def_k_sacclp_activation, (int)Activation())
kernelExecute(def_k_SAC_CalcLogProbs, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!cQuantile2.getOutput().BufferRead())
ReturnFalse;
#endif
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronSoftActorCritic::ReCalcLogProbs(void)
{
if(!OpenCL)
ReturnFalse;
//---
uint global_work_offset[1] = {0};
uint global_work_size[1] = {Neurons()};
setBuffer(def_k_SAC_CalcLogProbs, def_k_sacclp_alphas, cAlphas.getOutputIndex())
setBuffer(def_k_SAC_CalcLogProbs, def_k_sacclp_log_probs, cLogProbs.GetIndex())
setBuffer(def_k_SAC_CalcLogProbs, def_k_sacclp_outputs, Output.GetIndex())
setBuffer(def_k_SAC_CalcLogProbs, def_k_sacclp_probs, cSoftMax.getOutputIndex())
setBuffer(def_k_SAC_CalcLogProbs, def_k_sacclp_quantiles, cQuantile2.getOutputIndex())
setArgument(def_k_SAC_CalcLogProbs, def_k_sacclp_count_quants, (int)(cSoftMax.Neurons() / global_work_size[0]))
setArgument(def_k_SAC_CalcLogProbs, def_k_sacclp_activation, (int)Activation())
kernelExecute(def_k_SAC_CalcLogProbs, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!cQuantile2.getOutput().BufferRead())
ReturnFalse;
#endif
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronSoftActorCritic::calcInputGradients(CNeuronBaseOCL* NeuronOCL)
{
if(!NeuronOCL || !Gradient || !Output)
ReturnFalse;
//---
{
uint global_work_offset[1] = {0};
uint global_work_size[1] = { Neurons() };
setBuffer(def_k_SAC_OutputGradient, def_k_sacoutgr_quantiles, cQuantile2.getOutputIndex())
setBuffer(def_k_SAC_OutputGradient, def_k_sacoutgr_taus, cSoftMax.getOutputIndex())
setBuffer(def_k_SAC_OutputGradient, def_k_sacoutgr_output_gr, getGradientIndex())
setBuffer(def_k_SAC_OutputGradient, def_k_sacoutgr_quantiles_gr, cQuantile2.getGradientIndex())
setBuffer(def_k_SAC_OutputGradient, def_k_sacoutgr_taus_gr, cSoftMax.getGradientIndex())
setBuffer(def_k_SAC_OutputGradient, def_k_sacoutgr_outputs, getOutputIndex())
setArgument(def_k_SAC_OutputGradient, def_k_sacoutgr_activation, (int)Activation())
setArgument(def_k_SAC_OutputGradient, def_k_sacoutgr_count_quants, (int)(cSoftMax.Neurons() / Neurons()))
kernelExecute(def_k_SAC_OutputGradient, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!cSoftMax.getGradient().BufferRead())
ReturnFalse;
#endif
}
//---
if(!cQuantile1.CalcHiddenGradients((CObject *)GetPointer(cQuantile2)))
ReturnFalse;
if(!cQuantile0.CalcHiddenGradients((CObject *)GetPointer(cQuantile1)))
ReturnFalse;
//---
{
uint global_work_offset[2] = {0, 0};
uint global_work_size[2] = { cCosineEmbeding.Neurons(), 1 };
setBuffer(def_k_FQF_QuantileGradient, def_k_fqfqgr_state_enbeding, NeuronOCL.getOutputIndex())
setBuffer(def_k_FQF_QuantileGradient, def_k_fqfqgr_taus_embedding, cCosineEmbeding.getOutputIndex())
setBuffer(def_k_FQF_QuantileGradient, def_k_fqfqgr_quantiles_gr, cQuantile0.getGradientIndex())
setBuffer(def_k_FQF_QuantileGradient, def_k_fqfqgr_state_gr, NeuronOCL.getGradientIndex())
setBuffer(def_k_FQF_QuantileGradient, def_k_fqfqgr_taus_gr, cCosineEmbeding.getGradientIndex())
kernelExecute(def_k_FQF_QuantileGradient, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!cCosineEmbeding.getGradient().BufferRead())
ReturnFalse;
#endif
}
//---
if(!cCosine.CalcHiddenGradients((CObject *)GetPointer(cCosineEmbeding)))
ReturnFalse;
//---
{
uint global_work_offset[2] = {0, 0};
uint global_work_size[2] = { cSoftMax.Neurons() / Neurons(), Neurons() };
setBuffer(def_k_FQF_CosineGradient, def_k_fqfcosgr_softmax, cSoftMax.getOutputIndex())
setBuffer(def_k_FQF_CosineGradient, def_k_fqfcosgr_output_gr, cCosine.getGradientIndex())
setBuffer(def_k_FQF_CosineGradient, def_k_fqfcosgr_softmax_gr, cSoftMax.getGradientIndex())
kernelExecute(def_k_FQF_CosineGradient, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!cSoftMax.getGradient().BufferRead())
ReturnFalse;
#endif
}
if(!cSoftMax.CalcHiddenGradients((CObject *)GetPointer(cFraction)))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronSoftActorCritic::getCheckData(vector<float> &output, vector<float> &grad, vector<float> &quantiles, vector<float> &probability, vector<float> &alphas)
{
Output.GetData(output);
Gradient.GetData(grad);
cQuantile2.getGradient().GetData(quantiles);
cSoftMax.getGradient().GetData(probability);
cAlphas.getGradient().GetData(alphas);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFQF::WeightsUpdate(CNeuronBaseOCL* source, float tau)
{
if(!CNeuronBaseOCL::WeightsUpdate(source, tau))
ReturnFalse;
//---
CNeuronFQF *temp = source;
if(!cFraction.WeightsUpdate(GetPointer(temp.cFraction), tau))
ReturnFalse;
if(!cSoftMax.WeightsUpdate(GetPointer(temp.cSoftMax), tau))
ReturnFalse;
if(!cCosine.WeightsUpdate(GetPointer(temp.cCosine), tau))
ReturnFalse;
if(!cCosineEmbeding.WeightsUpdate(GetPointer(temp.cCosineEmbeding), tau))
ReturnFalse;
if(!cQuantile0.WeightsUpdate(GetPointer(temp.cQuantile0), tau))
ReturnFalse;
if(!cQuantile1.WeightsUpdate(GetPointer(temp.cQuantile1), tau))
ReturnFalse;
if(!cQuantile2.WeightsUpdate(GetPointer(temp.cQuantile2), tau))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPLROCL::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl, uint window_in, uint units_count, bool transpose, ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, window_in * units_count, optimization_type, batch))
ReturnFalse;
//---
iVariables = (int)window_in;
iCount = (int)units_count;
bTranspose = transpose;
//---
icIsTTP = OpenCL.AddBuffer(sizeof(int) * Neurons(), CL_MEM_READ_WRITE);
if(icIsTTP < 0)
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPLROCL::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!OpenCL || !NeuronOCL || !NeuronOCL.getOutput())
ReturnFalse;
//---
uint global_work_offset[2] = {0};
uint global_work_size[2] = {iCount, iVariables};
uint local_work_size[2] = {iCount, 1};
ResetLastError();
setBuffer(def_k_PLR, def_k_plr_inputs, NeuronOCL.getOutputIndex())
setBuffer(def_k_PLR, def_k_plr_outputs, getOutputIndex())
setBuffer(def_k_PLR, def_k_plt_isttp, icIsTTP)
setArgument(def_k_PLR, def_k_plr_transpose, (int)bTranspose)
setArgument(def_k_PLR, def_k_plr_step, (float)0.2)
//---
kernelExecuteLoc(def_k_PLR, global_work_offset, global_work_size, local_work_size)
#ifdef _DEBUG
if(!Output.BufferRead())
ReturnFalse;
#endif
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPLROCL::calcInputGradients(CNeuronBaseOCL* prevLayer)
{
if(!OpenCL || !prevLayer || !prevLayer.getGradient())
ReturnFalse;
//---
uint global_work_offset[2] = {0};
uint global_work_size[2] = {iCount, iVariables};
ResetLastError();
setBuffer(def_k_PLRGrad, def_k_plrg_inputs_gr, prevLayer.getGradientIndex())
setBuffer(def_k_PLRGrad, def_k_plrg_outputs, getOutputIndex())
setBuffer(def_k_PLRGrad, def_k_plrg_outputs_gr, getGradientIndex())
setArgument(def_k_PLRGrad, def_k_plr_transpose, (int)bTranspose)
//---
kernelExecute(def_k_PLRGrad, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!prevLayer.getGradient().BufferRead())
ReturnFalse;
#endif
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPLROCL::Save(const int file_handle)
{
if(!CNeuronBaseOCL::Save(file_handle))
ReturnFalse;
if(FileWriteInteger(file_handle, iCount) < INT_VALUE)
ReturnFalse;
if(FileWriteInteger(file_handle, iVariables) < INT_VALUE)
ReturnFalse;
if(FileWriteInteger(file_handle, int(bTranspose)) < INT_VALUE)
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPLROCL::Load(const int file_handle)
{
if(!CNeuronBaseOCL::Load(file_handle))
ReturnFalse;
//---
if(FileIsEnding(file_handle))
ReturnFalse;
iCount = FileReadInteger(file_handle);
if(FileIsEnding(file_handle))
ReturnFalse;
iVariables = FileReadInteger(file_handle);
if(FileIsEnding(file_handle))
ReturnFalse;
bTranspose = (bool)FileReadInteger(file_handle);
//---
OpenCL.BufferFree(icIsTTP);
icIsTTP = OpenCL.AddBuffer(sizeof(int) * Neurons(), CL_MEM_READ_WRITE);
if(icIsTTP < 0)
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronPLROCL::SetOpenCL(COpenCLMy * obj)
{
if(!!OpenCL && icIsTTP >= 0)
OpenCL.BufferFree(icIsTTP);
//---
CNeuronBaseOCL::SetOpenCL(obj);
icIsTTP = OpenCL.AddBuffer(sizeof(float) * Neurons(), CL_MEM_READ_WRITE);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMarketObserver::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count,
uint heads, uint layers, uint forecast,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
//--- Init parent object
if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, window * forecast, optimization_type, batch))
ReturnFalse;
//--- Clear layers' array
cLayers.Clear();
cLayers.SetOpenCL(OpenCL);
//--- Tranpose input data
int lay_count = 0;
CNeuronTransposeOCL *transp = new CNeuronTransposeOCL();
if(!transp ||
!transp.Init(0, lay_count, OpenCL, units_count, window, optimization, iBatch) ||
!cLayers.Add(transp))
{
DeleteObj(transp);
ReturnFalse;
}
//--- Piecewise linear representation
lay_count++;
CNeuronPLROCL *plr = new CNeuronPLROCL();
if(!plr ||
!plr.Init(0, lay_count, OpenCL, units_count, window, false, optimization, iBatch) ||
!cLayers.Add(plr))
{
DeleteObj(plr);
ReturnFalse;
}
//--- Self-Attention for Variables
lay_count++;
CNeuronRMAT *att = new CNeuronRMAT();
if(!att ||
!att.Init(0, lay_count, OpenCL, units_count, window_key, window, heads, layers, optimization, iBatch) ||
!cLayers.Add(att))
{
DeleteObj(att);
ReturnFalse;
}
//--- Forecast mapping
lay_count++;
CResidualConv *conv = new CResidualConv();
if(!conv ||
!conv.Init(0, lay_count, OpenCL, units_count, forecast, window, optimization, iBatch) ||
!cLayers.Add(conv))
{
DeleteObj(conv);
ReturnFalse;
}
//--- Back transpose forecast
lay_count++;
transp = new CNeuronTransposeOCL();
if(!transp ||
!transp.Init(0, lay_count, OpenCL, window, forecast, optimization, iBatch) ||
!cLayers.Add(transp))
{
DeleteObj(transp);
ReturnFalse;
}
//---
if(!SetOutput(transp.getOutput(), true) ||
!SetGradient(transp.getGradient(), true))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronRLAgent::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint units_count, uint segments,
float rho, uint layers, uint n_actions,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
//--- Init parent object
if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, n_actions, optimization_type, batch))
ReturnFalse;
//--- Clear layers' array
cLayers.Clear();
cLayers.SetOpenCL(OpenCL);
//--- State observation
int lay_count = 0;
for(uint i = 0; i < layers; i++)
{
CNeuronPSformer *psf = new CNeuronPSformer();
if(!psf ||
!psf.Init(0, lay_count, OpenCL, window, units_count, segments, rho, optimization, iBatch) ||
!cLayers.Add(psf))
{
DeleteObj(psf);
ReturnFalse;
}
lay_count++;
}
//---
CNeuronConvSAMOCL *conv = new CNeuronConvSAMOCL();
if(!conv ||
!conv.Init(n_actions, lay_count, OpenCL, window, window, 1, units_count, 1, optimization, iBatch) ||
!cLayers.Add(conv))
{
DeleteObj(conv);
ReturnFalse;
}
conv.SetActivationFunction(GELU);
lay_count++;
CNeuronBaseSAMOCL *flat = new CNeuronBaseSAMOCL();
if(!flat ||
!flat.Init(0, lay_count, OpenCL, n_actions, optimization, iBatch) ||
!cLayers.Add(flat))
{
DeleteObj(flat);
ReturnFalse;
}
SetActivationFunction(SIGMOID);
//---
if(!SetOutput(flat.getOutput(), true) ||
!SetGradient(flat.getGradient(), true))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronControlAgent::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count,
uint heads, uint window_kv, uint units_kv, uint layers,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
//--- Init parent object
if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, window * units_count, optimization_type, batch))
ReturnFalse;
//--- Clear layers' array
cLayers.Clear();
cLayers.SetOpenCL(OpenCL);
//--- Second buffer prepare
int lay_count = 0;
CNeuronBaseOCL *flat = new CNeuronBaseOCL();
if(!flat ||
!flat.Init(0, lay_count, OpenCL, window_kv * units_kv, optimization, iBatch) ||
!cLayers.Add(flat))
{
DeleteObj(flat);
ReturnFalse;
}
lay_count++;
CNeuronTransposeOCL *transp = new CNeuronTransposeOCL();
if(!transp ||
!transp.Init(0, lay_count, OpenCL, units_kv, window_kv, optimization, iBatch) ||
!cLayers.Add(transp))
{
DeleteObj(transp);
ReturnFalse;
}
lay_count++;
//--- Attention Action To Observation
for(uint i = 0; i < layers; i++)
{
if(units_count > 1)
{
CNeuronRelativeSelfAttention *self = new CNeuronRelativeSelfAttention();
if(!self ||
!self.Init(0, lay_count, OpenCL, window, window_key, units_count, heads, optimization, iBatch) ||
!cLayers.Add(self))
{
DeleteObj(self);
ReturnFalse;
}
lay_count++;
}
CNeuronRelativeCrossAttention *cross = new CNeuronRelativeCrossAttention();
if(!cross ||
!cross.Init(0, lay_count, OpenCL, window, window_key, units_count, heads, units_kv, window_kv, optimization, iBatch) ||
!cLayers.Add(cross))
{
DeleteObj(cross);
ReturnFalse;
}
lay_count++;
CResidualConv *ffn = new CResidualConv();
if(!ffn ||
!ffn.Init(0, lay_count, OpenCL, window, window, units_count, optimization, iBatch) ||
!cLayers.Add(ffn))
{
DeleteObj(ffn);
ReturnFalse;
}
lay_count++;
}
CNeuronConvSAMOCL *conv = new CNeuronConvSAMOCL();
if(!conv ||
!conv.Init(0, lay_count, OpenCL, window, window, window, units_count, 1, optimization, iBatch) ||
!cLayers.Add(conv))
{
DeleteObj(conv);
ReturnFalse;
}
SetActivationFunction(SIGMOID);
//---
if(!SetOutput(conv.getOutput(), true) ||
!SetGradient(conv.getGradient(), true))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronControlAgent::feedForward(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput)
{
if(!SecondInput)
ReturnFalse;
//---
CNeuronBaseOCL *second = cLayers[0];
if(!second)
ReturnFalse;
if(!second.SetOutput(SecondInput, true))
ReturnFalse;
//---
second = cLayers[1];
if(!second || !second.FeedForward(cLayers[0]))
ReturnFalse;
//---
CNeuronBaseOCL *first = NeuronOCL;
CNeuronBaseOCL *main = NULL;
for(int i = 2; i < cLayers.Total(); i++)
{
main = cLayers[i];
if(!main ||
!main.FeedForward(first, second.getOutput()))
ReturnFalse;
first = main;
}
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronControlAgent::calcInputGradients(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput, CBufferFloat* SecondGradient, ENUM_ACTIVATION SecondActivation = None)
{
if(!NeuronOCL || !SecondGradient)
ReturnFalse;
//---
CNeuronBaseOCL *main = cLayers[0];
if(!main)
ReturnFalse;
if(!main.SetGradient(SecondGradient, true))
ReturnFalse;
main.SetActivationFunction(SecondActivation);
//---
CNeuronBaseOCL *second = cLayers[1];
if(!second)
ReturnFalse;
second.SetActivationFunction(SecondActivation);
CBufferFloat *second_out = second.getOutput();
CBufferFloat *second_gr = second.getGradient();
CBufferFloat *temp = second.getPrevOutput();
if(!second_gr.Fill(0))
ReturnFalse;
//---
for(int i = cLayers.Total() - 2; i >= 2; i--)
{
main = cLayers[i];
if(!main)
ReturnFalse;
if(cLayers[i + 1].Type() == defNeuronRelativeCrossAttention)
{
if(!main.CalcHiddenGradients(cLayers[i + 1], second_out, temp, SecondActivation) ||
!SumAndNormalize(temp, second_gr, second_gr, 1, false, 0, 0, 0, 1))
ReturnFalse;
}
else
{
if(!main.CalcHiddenGradients(cLayers[i + 1]))
ReturnFalse;
}
}
//---
if(!NeuronOCL.CalcHiddenGradients(main.AsObject(), second_out, temp, SecondActivation))
ReturnFalse;
if(main.Type() == defNeuronRelativeCrossAttention)
{
if(!SumAndNormalize(temp, second_gr, second_gr, 1, false, 0, 0, 0, 1))
ReturnFalse;
}
main = cLayers[0];
if(!main.CalcHiddenGradients(second.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronControlAgent::updateInputWeights(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput)
{
CNeuronBaseOCL *second = cLayers[1];
CNeuronBaseOCL *main = NULL;
for(int i = cLayers.Total() - 1; i > 2; i--)
{
main = cLayers[i];
if(!main ||
!main.UpdateInputWeights(cLayers[i - 1], second.getOutput()))
ReturnFalse;
}
main = cLayers[2];
if(!main ||
!main.UpdateInputWeights(NeuronOCL, second.getOutput()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASA::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count,
uint heads_mo, uint layers_mo, uint forecast, uint segments_rl,
float rho, uint layers_rl, uint n_actions, uint heads_contr,
uint layers_contr, int NormLayer, CNeuronBatchNormOCL * normLayer,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronBaseSAMOCL::Init(numOutputs, myIndex, open_cl, n_actions, rho, optimization_type, batch))
ReturnFalse;
//--- Market Observation
if(!cMarketObserver.Init(0, 0, OpenCL, window, window_key, units_count, heads_mo, layers_mo, forecast, optimization, iBatch))
ReturnFalse;
if(!cRevIN.Init(0, 1, OpenCL, cMarketObserver.Neurons(), NormLayer, normLayer))
ReturnFalse;
//--- RL Agent
if(!cRLAgent.Init(0, 2, OpenCL, window, units_count, segments_rl, fRho, layers_rl, n_actions, optimization, iBatch))
ReturnFalse;
//---
if(!cControlAgent.Init(0, 3, OpenCL, 3, window_key, n_actions / 3, heads_contr, window, forecast, layers_contr, optimization, iBatch))
ReturnFalse;
//---
if(!SetOutput(cControlAgent.getOutput(), true) ||
!SetGradient(cControlAgent.getGradient(), true))
ReturnFalse;
SetActivationFunction(SIGMOID);
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronMASA::SetActivationFunction(ENUM_ACTIVATION value)
{
cControlAgent.SetActivationFunction(value);
cRLAgent.SetActivationFunction((ENUM_ACTIVATION)cControlAgent.Activation());
CNeuronBaseSAMOCL::SetActivationFunction((ENUM_ACTIVATION)cControlAgent.Activation());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASA::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!cMarketObserver.FeedForward(NeuronOCL.AsObject()))
ReturnFalse;
if(!cRLAgent.FeedForward(NeuronOCL.AsObject()))
ReturnFalse;
if(!cControlAgent.FeedForward(cRLAgent.AsObject(), cMarketObserver.getOutput()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASA::calcInputGradients(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput, CBufferFloat* SecondGradient, ENUM_ACTIVATION SecondActivation = None)
{
if(!NeuronOCL)
ReturnFalse;
//---
if(!cRevIN.FeedForward(cMarketObserver.AsObject()))
ReturnFalse;
float error = 1.0f;
if(!cRevIN.calcOutputGradients(SecondGradient, error))
ReturnFalse;
if(!cMarketObserver.CalcHiddenGradients(cRevIN.AsObject()))
ReturnFalse;
if(!cRLAgent.CalcHiddenGradients(cControlAgent.AsObject(), cMarketObserver.getOutput(),
cMarketObserver.getPrevOutput(),
(ENUM_ACTIVATION)cMarketObserver.Activation()) ||
!SumAndNormalize(cMarketObserver.getGradient(), cMarketObserver.getPrevOutput(), cMarketObserver.getGradient(), 1, false, 0, 0, 0, 1))
ReturnFalse;
//---
CBufferFloat *temp = cRLAgent.getGradient();
if(!cRLAgent.SetGradient(cRLAgent.getPrevOutput(), false) ||
!cRLAgent.calcOutputGradients(cControlAgent.getOutput(), error) ||
!SumAndNormalize(temp, cRLAgent.getPrevOutput(), temp, 1, false, 0, 0, 0, 1) ||
!cRLAgent.SetGradient(temp, false))
ReturnFalse;
//---
if(!NeuronOCL.CalcHiddenGradients(cMarketObserver.AsObject()))
ReturnFalse;
temp = NeuronOCL.getGradient();
if(!NeuronOCL.SetGradient(NeuronOCL.getPrevOutput(), false) ||
!NeuronOCL.calcOutputGradients(cRLAgent.getOutput(), error) ||
!SumAndNormalize(temp, NeuronOCL.getPrevOutput(), temp, 1, false, 0, 0, 0, 1) ||
!NeuronOCL.SetGradient(temp, false))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASA::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
if(!cControlAgent.UpdateInputWeights(cRLAgent.AsObject(), cMarketObserver.getOutput()))
ReturnFalse;
if(!cRLAgent.UpdateInputWeights(NeuronOCL))
ReturnFalse;
if(!cMarketObserver.UpdateInputWeights(NeuronOCL))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronMASA::SetOpenCL(COpenCLMy * obj)
{
CNeuronBaseSAMOCL::SetOpenCL(obj);
cMarketObserver.SetOpenCL(OpenCL);
cRevIN.SetOpenCL(OpenCL);
cRLAgent.SetOpenCL(OpenCL);
cControlAgent.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASA::Save(const int file_handle)
{
if(!CNeuronBaseSAMOCL::Save(file_handle))
ReturnFalse;
if(!cMarketObserver.Save(file_handle))
ReturnFalse;
if(!cRevIN.Save(file_handle))
ReturnFalse;
if(!cRLAgent.Save(file_handle))
ReturnFalse;
if(!cControlAgent.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASA::Load(const int file_handle)
{
if(!CNeuronBaseSAMOCL::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cMarketObserver.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cRevIN.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cRLAgent.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cControlAgent.AsObject()))
ReturnFalse;
//---
if(!SetOutput(cControlAgent.getOutput(), true) ||
!SetGradient(cControlAgent.getGradient(), true))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASA::SetNormLayer(int NormLayer, CNeuronBatchNormOCL * normLayer)
{
return cRevIN.Init(0, 1, OpenCL, cMarketObserver.Neurons(), NormLayer, normLayer);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPLRMultiAgentsOCL::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window_in, uint units_count, bool transpose,
vector<float> &min_distance,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
iAgents = (int)min_distance.Size();
if(iAgents <= 0)
ReturnFalse;
//---
if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, window_in * units_count * iAgents, optimization_type, batch))
ReturnFalse;
//---
iVariables = (int)window_in;
iCount = (int)units_count;
bTranspose = transpose;
//---
icIsTTP = OpenCL.AddBuffer(sizeof(int) * Neurons(), CL_MEM_READ_WRITE);
if(icIsTTP < 0)
ReturnFalse;
//---
if(!cMinDistance.AssignArray(min_distance) ||
!cMinDistance.BufferCreate(OpenCL))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPLRMultiAgentsOCL::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!OpenCL || !NeuronOCL || !NeuronOCL.getOutput())
ReturnFalse;
//---
uint global_work_offset[3] = {0};
uint global_work_size[3] = {iCount, iVariables, iAgents};
uint local_work_size[3] = {iCount, 1, 1};
ResetLastError();
const int kernel = def_k_PLRMultiAgents;
setBuffer(kernel, def_k_plr_inputs, NeuronOCL.getOutputIndex())
setBuffer(kernel, def_k_plr_outputs, getOutputIndex())
setBuffer(kernel, def_k_plt_isttp, icIsTTP)
setArgument(kernel, def_k_plr_transpose, (int)bTranspose)
setBuffer(kernel, def_k_plr_step, cMinDistance.GetIndex())
//---
kernelExecuteLoc(kernel, global_work_offset, global_work_size, local_work_size)
#ifdef _DEBUG
if(!Output.BufferRead())
ReturnFalse;
#endif
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPLRMultiAgentsOCL::calcInputGradients(CNeuronBaseOCL* prevLayer)
{
if(!OpenCL || !prevLayer || !prevLayer.getGradient())
ReturnFalse;
//---
uint global_work_offset[2] = {0};
uint global_work_size[2] = {iCount, iVariables};
ResetLastError();
const int kernel = def_k_PLRMultiAgentsGrad;
setBuffer(kernel, def_k_plrg_inputs_gr, prevLayer.getGradientIndex())
setBuffer(kernel, def_k_plrg_outputs, getOutputIndex())
setBuffer(kernel, def_k_plrg_outputs_gr, getGradientIndex())
setArgument(kernel, def_k_plrg_transpose, (int)bTranspose)
setArgument(kernel, def_k_plrg_agents, (int)iAgents)
//---
kernelExecute(kernel, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!prevLayer.getGradient().BufferRead())
ReturnFalse;
#endif
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPLRMultiAgentsOCL::Save(const int file_handle)
{
if(!CNeuronPLROCL::Save(file_handle))
ReturnFalse;
if(FileWriteInteger(file_handle, iAgents) < INT_VALUE)
ReturnFalse;
if(!cMinDistance.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPLRMultiAgentsOCL::Load(const int file_handle)
{
if(!CNeuronPLROCL::Load(file_handle))
ReturnFalse;
//---
if(FileIsEnding(file_handle))
ReturnFalse;
iAgents = FileReadInteger(file_handle);
if(!cMinDistance.Load(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronPLRMultiAgentsOCL::SetOpenCL(COpenCLMy * obj)
{
//---
CNeuronPLROCL::SetOpenCL(obj);
cMinDistance.BufferCreate(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronCrossSectionalAnalysis::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint heads, uint heads_kv,
uint units_count, uint layers, uint layers_to_one_kv, uint variables,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronMVMHAttentionMLKV::Init(numOutputs, myIndex, open_cl, window_key, window_key, heads, heads_kv,
variables, layers, layers_to_one_kv, units_count, optimization_type, batch))
ReturnFalse;
//---
if(!cEmbeding.Init(0, 0, OpenCL, window, window, window_key, units_count, variables, optimization, iBatch))
ReturnFalse;
cEmbeding.SetActivationFunction(GELU);
if(!cTransposeRCD.Init(0, 1, OpenCL, variables, units_count, window_key, optimization, iBatch))
ReturnFalse;
SetActivationFunction(None);
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronCrossSectionalAnalysis::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!cEmbeding.FeedForward(NeuronOCL))
ReturnFalse;
if(!cTransposeRCD.FeedForward(cEmbeding.AsObject()))
ReturnFalse;
//---
return CNeuronMVMHAttentionMLKV::feedForward(cTransposeRCD.AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronCrossSectionalAnalysis::calcInputGradients(CNeuronBaseOCL* prevLayer)
{
if(!prevLayer)
ReturnFalse;
if(!CNeuronMVMHAttentionMLKV::calcInputGradients(cTransposeRCD.AsObject()))
ReturnFalse;
if(!cEmbeding.CalcHiddenGradients(cTransposeRCD.AsObject()))
ReturnFalse;
if(cEmbeding.Activation() != None)
{
if(!DeActivation(cEmbeding.getOutput(), cEmbeding.getGradient(), cEmbeding.getGradient(), cEmbeding.Activation()))
ReturnFalse;
}
if(!prevLayer.CalcHiddenGradients(cEmbeding.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronCrossSectionalAnalysis::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
if(!CNeuronMVMHAttentionMLKV::updateInputWeights(cTransposeRCD.AsObject()))
ReturnFalse;
if(!cEmbeding.UpdateInputWeights(NeuronOCL))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronCrossSectionalAnalysis::SetOpenCL(COpenCLMy * obj)
{
CNeuronMVMHAttentionMLKV::SetOpenCL(obj);
cEmbeding.SetOpenCL(OpenCL);
cTransposeRCD.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronCrossSectionalAnalysis::Save(const int file_handle)
{
if(!CNeuronMVMHAttentionMLKV::Save(file_handle))
ReturnFalse;
if(!cEmbeding.Save(file_handle))
ReturnFalse;
if(!cTransposeRCD.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronCrossSectionalAnalysis::Load(const int file_handle)
{
if(!CNeuronMVMHAttentionMLKV::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cEmbeding.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cTransposeRCD.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronTemporalAnalysis::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint heads, uint heads_kv,
uint units_count, uint layers, uint layers_to_one_kv, uint variables,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronCrossSectionalAnalysis::Init(numOutputs, myIndex, open_cl, 3 * units_count, window_key, heads, heads_kv,
window / 3, layers, layers_to_one_kv, variables, optimization_type, batch))
ReturnFalse;
if(!cTranspose.Init(0, 0, OpenCL, variables, units_count, window, optimization_type, batch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronTemporalAnalysis::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!cTranspose.FeedForward(NeuronOCL))
ReturnFalse;
//---
return CNeuronCrossSectionalAnalysis::feedForward(cTranspose.AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronTemporalAnalysis::calcInputGradients(CNeuronBaseOCL* prevLayer)
{
if(!prevLayer)
ReturnFalse;
if(!CNeuronCrossSectionalAnalysis::calcInputGradients(cTranspose.AsObject()))
ReturnFalse;
//---
return prevLayer.CalcHiddenGradients(cTranspose.AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronTemporalAnalysis::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
return CNeuronCrossSectionalAnalysis::updateInputWeights(cTranspose.AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronTemporalAnalysis::SetOpenCL(COpenCLMy * obj)
{
CNeuronCrossSectionalAnalysis::SetOpenCL(obj);
cTranspose.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronTemporalAnalysis::Save(const int file_handle)
{
if(!CNeuronCrossSectionalAnalysis::Save(file_handle))
ReturnFalse;
if(!cTranspose.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronTemporalAnalysis::Load(const int file_handle)
{
if(!CNeuronCrossSectionalAnalysis::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cTranspose.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPortfolioGenerator::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint assets, uint time_points, uint dimension,
uint agents, uint projection,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(assets <= 0 || time_points <= 0 || dimension <= 0 || agents <= 0)
ReturnFalse;
if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, projection, optimization_type, batch))
ReturnFalse;
//---
iAssets = assets;
iTimePoints = time_points;
iDimension = dimension;
iAgents = agents;
//---
if(!cTransposeVRC.Init(0, 0, OpenCL, iAgents, iTimePoints, iDimension, optimization, iBatch))
ReturnFalse;
if(!cAssetTime[0].Init(0, 1, OpenCL, iAssets * iTimePoints * iAgents, optimization, iBatch))
ReturnFalse;
cAssetTime[0].SetActivationFunction(None);
if(!cSoftMax.Init(0, 2, OpenCL, cAssetTime[0].Neurons(), optimization, iBatch))
ReturnFalse;
cSoftMax.SetHeads(iAssets * iAgents);
if(!cAssetTime[1].Init(Neurons(), 3, OpenCL, iAssets * iDimension * iAgents, optimization, iBatch))
ReturnFalse;
cAssetTime[1].SetActivationFunction(None);
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPortfolioGenerator::feedForward(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput)
{
if(!SecondInput)
ReturnFalse;
//---
if(!cTransposeVRC.FeedForward(NeuronOCL))
ReturnFalse;
//---
if(!MatMul(SecondInput, cTransposeVRC.getOutput(), cAssetTime[0].getOutput(), iAssets, iDimension, iTimePoints, iAgents))
ReturnFalse;
if(!cSoftMax.FeedForward(cAssetTime[0].AsObject()))
ReturnFalse;
if(!MatMul(cSoftMax.getOutput(), NeuronOCL.getOutput(), cAssetTime[1].getOutput(), iAssets, iTimePoints, iDimension, iAgents))
ReturnFalse;
//---
return CNeuronBaseOCL::feedForward(cAssetTime[1].AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPortfolioGenerator::calcInputGradients(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput, CBufferFloat* SecondGradient, ENUM_ACTIVATION SecondActivation = None)
{
if(!NeuronOCL || !SecondGradient || !SecondInput)
ReturnFalse;
if(!CNeuronBaseOCL::calcInputGradients(cAssetTime[1].AsObject()))
ReturnFalse;
if(!MatMulGrad(cSoftMax.getOutput(), cSoftMax.getGradient(),
NeuronOCL.getOutput(), cTransposeVRC.getPrevOutput(),
cAssetTime[1].getGradient(),
iAssets, iTimePoints, iDimension, iAgents))
ReturnFalse;
if(!cAssetTime[0].CalcHiddenGradients(cSoftMax.AsObject()))
ReturnFalse;
if(!MatMulGrad(SecondInput, SecondGradient,
cTransposeVRC.getOutput(), cTransposeVRC.getGradient(),
cAssetTime[0].getGradient(),
iAssets, iDimension, iTimePoints, iAgents))
ReturnFalse;
if(SecondActivation != None)
if(!DeActivation(SecondInput, SecondGradient, SecondGradient, SecondActivation))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cTransposeVRC.AsObject()) ||
!SumAndNormalize(NeuronOCL.getGradient(), cTransposeVRC.getPrevOutput(), NeuronOCL.getGradient(), iDimension, false, 0, 0, 0, 1))
ReturnFalse;
if(NeuronOCL.Activation() != None)
if(!DeActivation(NeuronOCL.getOutput(), cTransposeVRC.getPrevOutput(), cTransposeVRC.getPrevOutput(), NeuronOCL.Activation()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPortfolioGenerator::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
return CNeuronBaseOCL::updateInputWeights(cAssetTime[1].AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronPortfolioGenerator::SetOpenCL(COpenCLMy * obj)
{
CNeuronBaseOCL::SetOpenCL(obj);
for(uint i = 0; i < cAssetTime.Size(); i++)
cAssetTime[i].SetOpenCL(OpenCL);
cTransposeVRC.SetOpenCL(OpenCL);
cSoftMax.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPortfolioGenerator::Save(const int file_handle)
{
if(!CNeuronBaseOCL::Save(file_handle))
ReturnFalse;
for(uint i = 0; i < cAssetTime.Size(); i++)
if(!cAssetTime[i].Save(file_handle))
ReturnFalse;
if(!cTransposeVRC.Save(file_handle))
ReturnFalse;
if(!cSoftMax.Save(file_handle))
ReturnFalse;
//---
if(FileWriteInteger(file_handle, (int)iAssets) < INT_VALUE)
ReturnFalse;
if(FileWriteInteger(file_handle, (int)iTimePoints) < INT_VALUE)
ReturnFalse;
if(FileWriteInteger(file_handle, (int)iAgents) < INT_VALUE)
ReturnFalse;
if(FileWriteInteger(file_handle, (int)iDimension) < INT_VALUE)
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronPortfolioGenerator::Load(const int file_handle)
{
if(!CNeuronBaseOCL::Load(file_handle))
ReturnFalse;
for(uint i = 0; i < cAssetTime.Size(); i++)
if(!LoadInsideLayer(file_handle, cAssetTime[i].AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cTransposeVRC.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cSoftMax.AsObject()))
ReturnFalse;
//---
if(FileIsEnding(file_handle))
ReturnFalse;
iAssets = (uint)FileReadInteger(file_handle);
if(FileIsEnding(file_handle))
ReturnFalse;
iTimePoints = (uint)FileReadInteger(file_handle);
if(FileIsEnding(file_handle))
ReturnFalse;
iAgents = (uint)FileReadInteger(file_handle);
if(FileIsEnding(file_handle))
ReturnFalse;
iDimension = (uint)FileReadInteger(file_handle);
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASAAT::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint heads, uint units_cout,
uint layers, vector<float> &min_distance, uint projection,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronPortfolioGenerator::Init(numOutputs, myIndex, open_cl, window, units_cout / 3,
window_key, (uint)min_distance.Size() + 1, projection, optimization_type, batch))
ReturnFalse;
if(!cTranspose.Init(0, 0, OpenCL, units_cout, window, optimization, iBatch))
ReturnFalse;
if(!cPLR.Init(0, 1, OpenCL, window, units_cout, false, min_distance, optimization, iBatch))
ReturnFalse;
if(!cConcat.Init(0, 2, OpenCL, cTranspose.Neurons() + cPLR.Neurons(), optimization, iBatch))
ReturnFalse;
if(!cCrossSectionalAnalysis.Init(0, 3, OpenCL, units_cout, window_key, heads, heads / 2, window, layers, 1, iAgents, optimization, iBatch))
ReturnFalse;
if(!cTemporalAnalysis.Init(0, 4, OpenCL, units_cout, window_key, heads, heads / 2, window, layers, 1, iAgents, optimization, iBatch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASAAT::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!cTranspose.FeedForward(NeuronOCL))
ReturnFalse;
if(!cPLR.FeedForward(cTranspose.AsObject()))
ReturnFalse;
if(!Concat(cTranspose.getOutput(), cPLR.getOutput(), cConcat.getOutput(), cTranspose.Neurons(), cPLR.Neurons(), 1))
ReturnFalse;
if(!cCrossSectionalAnalysis.FeedForward(cConcat.AsObject()))
ReturnFalse;
if(!cTemporalAnalysis.FeedForward(cConcat.AsObject()))
ReturnFalse;
//---
return CNeuronPortfolioGenerator::feedForward(cTemporalAnalysis.AsObject(), cCrossSectionalAnalysis.getOutput());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASAAT::calcInputGradients(CNeuronBaseOCL* prevLayer)
{
if(!prevLayer)
ReturnFalse;
if(!CNeuronPortfolioGenerator::calcInputGradients(cTemporalAnalysis.AsObject(),
cCrossSectionalAnalysis.getOutput(),
cCrossSectionalAnalysis.getGradient(),
(ENUM_ACTIVATION)cCrossSectionalAnalysis.Activation()))
ReturnFalse;
if(!cConcat.CalcHiddenGradients(cCrossSectionalAnalysis.AsObject()))
ReturnFalse;
CBufferFloat *grad = cConcat.getGradient();
if(!cConcat.SetGradient(cConcat.getPrevOutput(), false) ||
!cConcat.CalcHiddenGradients(cTemporalAnalysis.AsObject()) ||
!SumAndNormalize(grad, cConcat.getGradient(), grad, 1, 0, 0, 0, 0, 1) ||
!cConcat.SetGradient(grad, false))
ReturnFalse;
//---
if(!DeConcat(cTranspose.getPrevOutput(), cPLR.getGradient(), cConcat.getGradient(), cTranspose.Neurons(), cPLR.Neurons(), 1))
ReturnFalse;
if(cPLR.Activation() != None)
if(!DeActivation(cPLR.getOutput(), cPLR.getGradient(), cPLR.getGradient(), cPLR.Activation()))
ReturnFalse;
//---
if(!cTranspose.CalcHiddenGradients(cPLR.AsObject()) ||
!SumAndNormalize(cTranspose.getGradient(), cTranspose.getPrevOutput(), cTranspose.getGradient(), iDimension, false, 0, 0, 0, 1))
ReturnFalse;
if(cTranspose.Activation() != None)
if(!DeActivation(cTranspose.getOutput(), cTranspose.getGradient(), cTranspose.getGradient(), cTranspose.Activation()))
ReturnFalse;
if(!prevLayer.CalcHiddenGradients(cTranspose.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASAAT::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
if(!cCrossSectionalAnalysis.UpdateInputWeights(cConcat.AsObject()))
ReturnFalse;
if(!cTemporalAnalysis.UpdateInputWeights(cConcat.AsObject()))
ReturnFalse;
//---
return CNeuronPortfolioGenerator::updateInputWeights(cTemporalAnalysis.AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronMASAAT::SetOpenCL(COpenCLMy * obj)
{
CNeuronPortfolioGenerator::SetOpenCL(obj);
cTranspose.SetOpenCL(OpenCL);
cPLR.SetOpenCL(OpenCL);
cConcat.SetOpenCL(OpenCL);
cCrossSectionalAnalysis.SetOpenCL(OpenCL);
cTemporalAnalysis.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASAAT::Save(const int file_handle)
{
if(!CNeuronPortfolioGenerator::Save(file_handle))
ReturnFalse;
if(!cTranspose.Save(file_handle))
ReturnFalse;
if(!cPLR.Save(file_handle))
ReturnFalse;
if(!cCrossSectionalAnalysis.Save(file_handle))
ReturnFalse;
if(!cTemporalAnalysis.Save(file_handle))
ReturnFalse;
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMASAAT::Load(const int file_handle)
{
if(!CNeuronPortfolioGenerator::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cTranspose.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cPLR.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cCrossSectionalAnalysis.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cTemporalAnalysis.AsObject()))
ReturnFalse;
//---
if(!cConcat.Init(0, 2, OpenCL, cTranspose.Neurons() + cPLR.Neurons(), optimization, iBatch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemory::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count, uint heads,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronRelativeCrossAttention::Init(numOutputs, myIndex, open_cl, window, window_key,
units_count, heads, window, units_count, optimization_type, batch))
ReturnFalse;
if(!cLSTM.Init(0, 0, OpenCL, iWindow, iUnits, optimization, iBatch))
ReturnFalse;
if(!cMamba.Init(0, 1, OpenCL, iWindow, 2 * iWindow, iUnits, optimization, iBatch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemory::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!cLSTM.FeedForward(NeuronOCL))
ReturnFalse;
if(!cMamba.FeedForward(NeuronOCL))
ReturnFalse;
//---
return CNeuronRelativeCrossAttention::feedForward(cMamba.AsObject(), cLSTM.getOutput());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemory::calcInputGradients(CNeuronBaseOCL* NeuronOCL)
{
if(!NeuronOCL)
ReturnFalse;
if(!CNeuronRelativeCrossAttention::calcInputGradients(cMamba.AsObject(), cLSTM.getOutput(),
cLSTM.getGradient(), (ENUM_ACTIVATION)cLSTM.Activation()))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cMamba.AsObject()))
ReturnFalse;
CBufferFloat *temp = NeuronOCL.getGradient();
if(!NeuronOCL.SetGradient(cMamba.getPrevOutput(), false))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cLSTM.AsObject()))
ReturnFalse;
if(!NeuronOCL.SetGradient(temp, false) ||
!SumAndNormalize(temp, cMamba.getPrevOutput(), temp, iWindow, false, 0, 0, 0, 1))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemory::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
if(!CNeuronRelativeCrossAttention::updateInputWeights(cMamba.AsObject(), cLSTM.getOutput()))
ReturnFalse;
if(!cLSTM.UpdateInputWeights(NeuronOCL))
ReturnFalse;
if(!cMamba.UpdateInputWeights(NeuronOCL))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronMemory::SetOpenCL(COpenCLMy * obj)
{
CNeuronRelativeCrossAttention::SetOpenCL(obj);
cLSTM.SetOpenCL(OpenCL);
cMamba.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemory::Save(const int file_handle)
{
if(!CNeuronRelativeCrossAttention::Save(file_handle))
ReturnFalse;
if(!cLSTM.Save(file_handle))
ReturnFalse;
if(!cMamba.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemory::Load(const int file_handle)
{
if(!CNeuronRelativeCrossAttention::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cLSTM.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cMamba.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemory::Clear(void)
{
if(!CNeuronRelativeCrossAttention::Clear())
ReturnFalse;
if(!cLSTM.Clear())
ReturnFalse;
if(!cMamba.Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinMem::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count, uint heads,
uint account_descr, uint nactions,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronRelativeCrossAttention::Init(numOutputs, myIndex, open_cl,
nactions / 2, window_key, 2, heads, window,
units_count, optimization_type, batch))
ReturnFalse;
//---
int index = 0;
if(!cTransposeState.Init(0, index, OpenCL, units_count, window, optimization, iBatch))
ReturnFalse;
index++;
if(!cMemory[0].Init(0, index, OpenCL, window, window_key, units_count, heads, optimization, iBatch))
ReturnFalse;
index++;
if(!cMemory[1].Init(0, index, OpenCL, units_count, window_key, window, heads, optimization, iBatch))
ReturnFalse;
index++;
if(!cCrossMemory.Init(0, index, OpenCL, window, window_key, units_count, heads, units_count, window, optimization, iBatch))
ReturnFalse;
index++;
if(!cMemoryToAccount.Init(0, index, OpenCL, window, window_key, units_count, heads, account_descr, 1, optimization, iBatch))
ReturnFalse;
index++;
if(!cActionToAccount.Init(0, index, OpenCL, nactions / 2, window_key, 2, heads, account_descr, 1, optimization, iBatch))
ReturnFalse;
//---
if(!Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinMem::feedForward(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput)
{
if(!cTransposeState.FeedForward(NeuronOCL))
ReturnFalse;
if(!cMemory[0].FeedForward(NeuronOCL) ||
!cMemory[1].FeedForward(cTransposeState.AsObject()))
ReturnFalse;
if(!cCrossMemory.FeedForward(cMemory[0].AsObject(), cMemory[1].getOutput()))
ReturnFalse;
if(!cMemoryToAccount.FeedForward(cCrossMemory.AsObject(), SecondInput))
ReturnFalse;
if(!cActionToAccount.FeedForward(this.AsObject(), SecondInput))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
if(!CNeuronRelativeCrossAttention::feedForward(cActionToAccount.AsObject(), cMemoryToAccount.getOutput()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinMem::calcInputGradients(CNeuronBaseOCL* NeuronOCL,
CBufferFloat* SecondInput,
CBufferFloat* SecondGradient,
ENUM_ACTIVATION SecondActivation = None)
{
if(!NeuronOCL || !SecondInput || !SecondGradient)
ReturnFalse;
//---
if(!CNeuronRelativeCrossAttention::calcInputGradients(cActionToAccount.AsObject(),
cMemoryToAccount.getOutput(),
cMemoryToAccount.getGradient(),
(ENUM_ACTIVATION)cMemoryToAccount.Activation()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
CBufferFloat *temp = Gradient;
if(!SetGradient(cMemoryToAccount.getPrevOutput(), false))
ReturnFalse;
if(!calcHiddenGradients(cActionToAccount.AsObject(), SecondInput, SecondGradient, SecondActivation))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
Gradient = temp;
if(!cCrossMemory.CalcHiddenGradients(cMemoryToAccount.AsObject(), SecondInput, cMemoryToAccount.getPrevOutput(), SecondActivation))
ReturnFalse;
if(!SumAndNormalize(SecondGradient, cMemoryToAccount.getPrevOutput(), SecondGradient, 1, false, 0, 0, 0, 1))
ReturnFalse;
if(!cMemory[0].CalcHiddenGradients(cCrossMemory.AsObject(), cMemory[1].getOutput(), cMemory[1].getGradient(), (ENUM_ACTIVATION)cMemory[1].Activation()))
ReturnFalse;
if(!cTransposeState.CalcHiddenGradients(cMemory[1].AsObject()))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cMemory[0].AsObject()))
ReturnFalse;
temp = NeuronOCL.getGradient();
if(!NeuronOCL.SetGradient(cTransposeState.getPrevOutput(), false) ||
!NeuronOCL.CalcHiddenGradients(cTransposeState.AsObject()) ||
!NeuronOCL.SetGradient(temp, false) ||
!SumAndNormalize(temp, cTransposeState.getPrevOutput(), temp, iWindow, false, 0, 0, 0, 1))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinMem::updateInputWeights(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput)
{
if(!NeuronOCL || !SecondInput)
ReturnFalse;
//---
if(!CNeuronRelativeCrossAttention::updateInputWeights(cActionToAccount.AsObject(),
cMemoryToAccount.getOutput()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
if(!cActionToAccount.UpdateInputWeights(this.AsObject(), SecondInput))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
if(!cMemoryToAccount.UpdateInputWeights(cCrossMemory.AsObject(), SecondInput))
ReturnFalse;
if(!cCrossMemory.UpdateInputWeights(cMemory[0].AsObject(), cMemory[1].getOutput()))
ReturnFalse;
if(!cMemory[1].UpdateInputWeights(cTransposeState.AsObject()))
ReturnFalse;
if(!cMemory[0].UpdateInputWeights(NeuronOCL))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinMem::Clear(void)
{
if(!Output ||
!Output.Fill(0))
ReturnFalse;
for(uint i = 0; i < cMemory.Size(); i++)
if(!cMemory[i].Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronFinMem::SetOpenCL(COpenCLMy * obj)
{
CNeuronRelativeCrossAttention::SetOpenCL(obj);
cTransposeState.SetOpenCL(OpenCL);
for(uint i = 0; i < cMemory.Size(); i++)
cMemory[i].SetOpenCL(OpenCL);
cCrossMemory.SetOpenCL(OpenCL);
cMemoryToAccount.SetOpenCL(OpenCL);
cActionToAccount.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinMem::Save(const int file_handle)
{
if(!CNeuronRelativeCrossAttention::Save(file_handle))
ReturnFalse;
if(!cTransposeState.Save(file_handle))
ReturnFalse;
for(uint i = 0; i < cMemory.Size(); i++)
if(!cMemory[i].Save(file_handle))
ReturnFalse;
if(!cCrossMemory.Save(file_handle))
ReturnFalse;
if(!cMemoryToAccount.Save(file_handle))
ReturnFalse;
if(!cActionToAccount.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinMem::Load(const int file_handle)
{
if(!CNeuronRelativeCrossAttention::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cTransposeState.AsObject()))
ReturnFalse;
for(uint i = 0; i < cMemory.Size(); i++)
if(!LoadInsideLayer(file_handle, cMemory[i].AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cCrossMemory.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cMemoryToAccount.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cActionToAccount.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronLowLevelReflection::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count, uint heads,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronMemory::Init(numOutputs, myIndex, open_cl, window, window_key, units_count, heads,
optimization_type, batch))
ReturnFalse;
//---
int index = 0;
if(!cChangeLSTM.Init(0, index, OpenCL, window, units_count, optimization, iBatch))
ReturnFalse;
index++;
if(!cChangeMamba.Init(0, index, OpenCL, window, 2 * window, units_count, optimization, iBatch))
ReturnFalse;
for(int i = 0; i < 2; i++)
{
index++;
if(!cCrossAttention[i].Init(0, index, OpenCL, window, window_key, units_count, heads, window, units_count, optimization, iBatch))
ReturnFalse;
}
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronLowLevelReflection::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!cChangeLSTM.FeedForward(NeuronOCL))
ReturnFalse;
if(!cChangeMamba.FeedForward(NeuronOCL))
ReturnFalse;
if(!cCrossAttention[0].FeedForward(NeuronOCL, cChangeLSTM.getOutput()))
ReturnFalse;
if(!cCrossAttention[1].FeedForward(cCrossAttention[0].AsObject(), cChangeMamba.getOutput()))
ReturnFalse;
//---
return CNeuronMemory::feedForward(cCrossAttention[1].AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronLowLevelReflection::calcInputGradients(CNeuronBaseOCL* NeuronOCL)
{
if(!NeuronOCL)
ReturnFalse;
//---
if(!CNeuronMemory::calcInputGradients(cCrossAttention[1].AsObject()))
ReturnFalse;
if(!cCrossAttention[0].CalcHiddenGradients(cCrossAttention[1].AsObject(), cChangeMamba.getOutput(),
cChangeMamba.getGradient(), (ENUM_ACTIVATION)cChangeMamba.Activation()))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cCrossAttention[0].AsObject(), cChangeLSTM.getOutput(),
cChangeLSTM.getGradient(), (ENUM_ACTIVATION)cChangeLSTM.Activation()))
ReturnFalse;
CBufferFloat *temp = NeuronOCL.getGradient();
if(!NeuronOCL.SetGradient(cChangeMamba.getPrevOutput(), false) ||
!NeuronOCL.CalcHiddenGradients(cChangeMamba.AsObject()) ||
!SumAndNormalize(NeuronOCL.getGradient(), temp, temp, iWindow, false, 0, 0, 0, 1))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cChangeLSTM.AsObject()) ||
!SumAndNormalize(NeuronOCL.getGradient(), temp, temp, iWindow, false, 0, 0, 0, 1))
ReturnFalse;
if(!NeuronOCL.SetGradient(temp, false))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronLowLevelReflection::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
if(!CNeuronMemory::updateInputWeights(cCrossAttention[1].AsObject()))
ReturnFalse;
if(!cCrossAttention[1].UpdateInputWeights(cCrossAttention[0].AsObject(), cChangeMamba.getOutput()))
ReturnFalse;
if(!cCrossAttention[0].UpdateInputWeights(NeuronOCL, cChangeLSTM.getOutput()))
ReturnFalse;
if(!cChangeMamba.UpdateInputWeights(NeuronOCL))
ReturnFalse;
if(!cChangeLSTM.UpdateInputWeights(NeuronOCL))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronLowLevelReflection::Save(const int file_handle)
{
if(!CNeuronMemory::Save(file_handle))
ReturnFalse;
if(!cChangeLSTM.Save(file_handle))
ReturnFalse;
if(!cChangeMamba.Save(file_handle))
ReturnFalse;
for(uint i = 0; i < cCrossAttention.Size(); i++)
if(!cCrossAttention[i].Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronLowLevelReflection::Load(const int file_handle)
{
if(!CNeuronMemory::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cChangeLSTM.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cChangeMamba.AsObject()))
ReturnFalse;
for(uint i = 0; i < cCrossAttention.Size(); i++)
if(!LoadInsideLayer(file_handle, cCrossAttention[i].AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronLowLevelReflection::SetOpenCL(COpenCLMy * obj)
{
CNeuronMemory::SetOpenCL(obj);
cChangeLSTM.SetOpenCL(OpenCL);
cChangeMamba.SetOpenCL(OpenCL);
for(uint i = 0; i < cCrossAttention.Size(); i++)
cCrossAttention[i].SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronLowLevelReflection::Clear(void)
{
if(!CNeuronMemory::Clear())
ReturnFalse;
if(!cChangeLSTM.Clear())
ReturnFalse;
if(!cChangeMamba.Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHighLevelReflection::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count,
uint heads, uint desc_account, uint actions_state,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronMemory::Init(numOutputs, myIndex, open_cl, 3, window_key, actions_state / 3,
heads, optimization_type, batch))
ReturnFalse;
//---
int index = 0;
if(!cAccount.Init(0, index, OpenCL, desc_account, optimization, iBatch))
ReturnFalse;
index++;
if(!cHistoryAccount.Init(0, index, OpenCL, desc_account, 1, optimization, iBatch))
ReturnFalse;
index++;
if(!cActionReason.Init(0, index, OpenCL, iWindow, iWindowKey, iUnits, iHeads,
window, units_count, optimization, iBatch))
ReturnFalse;
index++;
if(!cHistoryActions.Init(0, index, OpenCL, iWindow, iUnits, optimization, iBatch))
ReturnFalse;
index++;
if(!cActionResult.Init(0, index, OpenCL, iWindow, iWindowKey, iUnits, iHeads,
desc_account, 1, optimization, iBatch))
ReturnFalse;;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHighLevelReflection::feedForward(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput)
{
if(!NeuronOCL || !SecondInput)
ReturnFalse;
//---
if(cAccount.getOutput() != SecondInput)
{
if(cAccount.Neurons() != SecondInput.Total())
if(!cAccount.Init(0, 0, OpenCL, SecondInput.Total(), optimization, iBatch))
ReturnFalse;
if(!cAccount.SetOutput(SecondInput, true))
ReturnFalse;
}
//---
if(!cHistoryAccount.FeedForward(cAccount.AsObject()))
ReturnFalse;
if(!cActionReason.FeedForward(this.AsObject(), NeuronOCL.getOutput()))
ReturnFalse;
if(!cHistoryActions.FeedForward(cActionReason.AsObject()))
ReturnFalse;
if(!cActionResult.FeedForward(cHistoryActions.AsObject(), cHistoryAccount.getOutput()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
//---
return CNeuronMemory::feedForward(cActionResult.AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHighLevelReflection::calcInputGradients(CNeuronBaseOCL* NeuronOCL,
CBufferFloat* SecondInput,
CBufferFloat* SecondGradient,
ENUM_ACTIVATION SecondActivation = None)
{
if(!NeuronOCL || !SecondGradient)
ReturnFalse;
//---
if(cAccount.getGradient() != SecondGradient)
if(!cAccount.SetGradient(SecondGradient, true))
ReturnFalse;
cAccount.SetActivationFunction(SecondActivation);
//---
if(!CNeuronMemory::calcInputGradients(cActionResult.AsObject()))
ReturnFalse;
if(!cHistoryActions.CalcHiddenGradients(cActionResult.AsObject(),
cHistoryAccount.getOutput(),
cHistoryAccount.getGradient(),
(ENUM_ACTIVATION)cHistoryAccount.Activation()))
ReturnFalse;
if(!cActionReason.CalcHiddenGradients(cHistoryActions.AsObject()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
CBufferFloat *temp = Gradient;
Gradient = cActionReason.getPrevOutput();
if(!calcHiddenGradients(cActionReason.AsObject(), NeuronOCL.getOutput(),
NeuronOCL.getGradient(), (ENUM_ACTIVATION)NeuronOCL.Activation()))
ReturnFalse;
//---
Gradient = temp;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
//---
if(!cAccount.CalcHiddenGradients(cHistoryAccount.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHighLevelReflection::updateInputWeights(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput)
{
if(!CNeuronMemory::updateInputWeights(cActionResult.AsObject()))
ReturnFalse;
if(!cActionResult.UpdateInputWeights(cHistoryActions.AsObject(), cHistoryAccount.getOutput()))
ReturnFalse;
if(!cHistoryActions.UpdateInputWeights(cActionReason.AsObject()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
if(!cActionReason.UpdateInputWeights(this.AsObject(), NeuronOCL.getOutput()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
if(!cHistoryAccount.UpdateInputWeights(cAccount.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHighLevelReflection::Save(const int file_handle)
{
if(!CNeuronMemory::Save(file_handle))
ReturnFalse;
if(!cAccount.Save(file_handle))
ReturnFalse;
if(!cHistoryAccount.Save(file_handle))
ReturnFalse;
if(!cActionReason.Save(file_handle))
ReturnFalse;
if(!cHistoryActions.Save(file_handle))
ReturnFalse;
if(!cActionResult.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHighLevelReflection::Load(const int file_handle)
{
if(!CNeuronMemory::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cAccount.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cHistoryAccount.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cActionReason.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cHistoryActions.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cActionResult.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronHighLevelReflection::SetOpenCL(COpenCLMy * obj)
{
CNeuronMemory::SetOpenCL(obj);
cAccount.SetOpenCL(OpenCL);
cHistoryAccount.SetOpenCL(OpenCL);
cActionReason.SetOpenCL(OpenCL);
cHistoryActions.SetOpenCL(OpenCL);
cActionResult.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHighLevelReflection::Clear(void)
{
if(!CNeuronMemory::Clear())
ReturnFalse;
if(!cAccount.Clear())
ReturnFalse;
if(!cHistoryAccount.Clear())
ReturnFalse;
if(!cActionReason.Clear())
ReturnFalse;
if(!cHistoryActions.Clear())
ReturnFalse;
if(!cActionResult.Clear())
ReturnFalse;;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMoreLessEqual::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!OpenCL || !NeuronOCL)
ReturnFalse;
uint global_work_offset[1] = { 0 };
uint global_work_size[1] = { Neurons() };
ResetLastError();
const int kernel = def_k_MoreLessEqual;
setBuffer(kernel, def_k_mle_inputs, NeuronOCL.getOutputIndex())
setBuffer(kernel, def_k_mle_outputs, getOutputIndex())
//---
kernelExecute(kernel, global_work_offset, global_work_size)
#ifdef _DEBUG
if(!NeuronOCL.getOutput().BufferRead())
ReturnFalse;
#endif
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMoreLessEqual::calcInputGradients(CNeuronBaseOCL* NeuronOCL)
{
if(!NeuronOCL || !NeuronOCL.getGradient())
ReturnFalse;
return NeuronOCL.getGradient().Fill(0);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinAgent::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count, uint heads,
uint account_descr, uint nactions, uint segments,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronRelativeCrossAttention::Init(numOutputs, myIndex, open_cl, 3,
window_key, nactions / 3, heads,
window, units_count,
optimization_type, batch))
ReturnFalse;
int index = 0;
if(!cMarketIntelligence.Init(0, index, OpenCL, window, units_count, segments, 0.2f, optimization, iBatch))
ReturnFalse;
index++;
if(!cMarketMemory.Init(0, index, OpenCL, window, window_key, units_count, heads, optimization, iBatch))
ReturnFalse;
index++;
if(!cTransposeState.Init(0, index, OpenCL, units_count, window, optimization, iBatch))
ReturnFalse;
index++;
if(!cLowLevelReflection[0].Init(0, index, OpenCL, window, window_key, units_count, heads, optimization, iBatch))
ReturnFalse;
index++;
if(!cLowLevelReflection[1].Init(0, index, OpenCL, units_count, window_key, window, heads, optimization, iBatch))
ReturnFalse;
index++;
if(!cHighLevelReflection.Init(0, index, OpenCL, window, window_key, units_count, heads, account_descr, nactions, optimization, iBatch))
ReturnFalse;
index++;
if(!cTools.Init(0, index, OpenCL, window * units_count, optimization, iBatch))
ReturnFalse;
cTools.SetActivationFunction(None);
index++;
if(!cCrossLowLevel.Init(0, index, OpenCL, window, window_key, units_count, heads, units_count, window, optimization, iBatch))
ReturnFalse;
index++;
if(!cMarketToLowLevel.Init(0, index, OpenCL, window, window_key, units_count, heads, window, units_count, optimization, iBatch))
ReturnFalse;
index++;
if(!cMarketToTools.Init(0, index, OpenCL, window, window_key, units_count, heads, window, units_count, optimization, iBatch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinAgent::feedForward(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput)
{
if(!cMarketIntelligence.FeedForward(NeuronOCL))
ReturnFalse;
if(!cMarketMemory.FeedForward(cMarketIntelligence.AsObject()))
ReturnFalse;
if(!cTransposeState.FeedForward(cMarketIntelligence.AsObject()))
ReturnFalse;
if(!cLowLevelReflection[0].FeedForward(cMarketIntelligence.AsObject()))
ReturnFalse;
if(!cLowLevelReflection[1].FeedForward(cTransposeState.AsObject()))
ReturnFalse;
if(!cHighLevelReflection.FeedForward(cMarketIntelligence.AsObject(), SecondInput))
ReturnFalse;
if(!cTools.FeedForward(NeuronOCL))
ReturnFalse;
if(!cCrossLowLevel.FeedForward(cLowLevelReflection[0].AsObject(), cLowLevelReflection[1].getOutput()))
ReturnFalse;
if(!cMarketToLowLevel.FeedForward(cMarketMemory.AsObject(), cCrossLowLevel.getOutput()))
ReturnFalse;
if(!cMarketToTools.FeedForward(cMarketToLowLevel.AsObject(), cTools.getOutput()))
ReturnFalse;
//---
return CNeuronRelativeCrossAttention::feedForward(cHighLevelReflection.AsObject(), cMarketToTools.getOutput());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinAgent::calcInputGradients(CNeuronBaseOCL* NeuronOCL,
CBufferFloat* SecondInput,
CBufferFloat* SecondGradient,
ENUM_ACTIVATION SecondActivation = None)
{
if(!NeuronOCL || !SecondGradient)
ReturnFalse;
//---
if(!CNeuronRelativeCrossAttention::calcInputGradients(cHighLevelReflection.AsObject(),
cMarketToTools.getOutput(),
cMarketToTools.getGradient(),
(ENUM_ACTIVATION)cMarketToTools.Activation()))
ReturnFalse;
//---
if(!cMarketToLowLevel.CalcHiddenGradients(cMarketToTools.AsObject(),
cTools.getOutput(),
cTools.getGradient(),
(ENUM_ACTIVATION)cTools.Activation()))
ReturnFalse;
//---
if(!cMarketMemory.CalcHiddenGradients(cMarketToLowLevel.AsObject(),
cCrossLowLevel.getOutput(),
cCrossLowLevel.getGradient(),
(ENUM_ACTIVATION)cCrossLowLevel.Activation()))
ReturnFalse;
//---
if(!cLowLevelReflection[0].CalcHiddenGradients(cCrossLowLevel.AsObject(),
cLowLevelReflection[1].getOutput(),
cLowLevelReflection[1].getGradient(),
(ENUM_ACTIVATION)cLowLevelReflection[1].Activation()))
ReturnFalse;
if(!cTransposeState.CalcHiddenGradients(cLowLevelReflection[1].AsObject()))
ReturnFalse;
//---
if(!((CNeuronBaseOCL*)cMarketIntelligence.AsObject()).CalcHiddenGradients(cMarketMemory.AsObject()))
ReturnFalse;
CBufferFloat *temp = cMarketIntelligence.getGradient();
if(!cMarketIntelligence.SetGradient(cMarketIntelligence.getPrevOutput(), false) ||
!((CNeuronBaseOCL*)cMarketIntelligence.AsObject()).CalcHiddenGradients(cHighLevelReflection.AsObject(),
SecondInput, SecondGradient, SecondActivation) ||
!SumAndNormalize(temp, cMarketIntelligence.getGradient(), temp, 1, false, 0, 0, 0, 1))
ReturnFalse;
if(!((CNeuronBaseOCL*)cMarketIntelligence.AsObject()).CalcHiddenGradients(cLowLevelReflection[0].AsObject()) ||
!SumAndNormalize(temp, cMarketIntelligence.getGradient(), temp, 1, false, 0, 0, 0, 1))
ReturnFalse;
if(!((CNeuronBaseOCL*)cMarketIntelligence.AsObject()).CalcHiddenGradients(cTransposeState.AsObject()) ||
!SumAndNormalize(temp, cMarketIntelligence.getGradient(), temp, 1, false, 0, 0, 0, 1) ||
!cMarketIntelligence.SetGradient(temp, false))
ReturnFalse;
//---
if(!NeuronOCL.CalcHiddenGradients(cMarketIntelligence.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinAgent::updateInputWeights(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput)
{
//---
if(!CNeuronRelativeCrossAttention::updateInputWeights(cHighLevelReflection.AsObject(),
cMarketToTools.getOutput()))
ReturnFalse;
//---
if(!cMarketToTools.UpdateInputWeights(cMarketToLowLevel.AsObject(),
cTools.getOutput()))
ReturnFalse;
//---
if(!cMarketToLowLevel.UpdateInputWeights(cMarketMemory.AsObject(),
cCrossLowLevel.getOutput()))
ReturnFalse;
if(!cMarketMemory.UpdateInputWeights(cMarketIntelligence.AsObject()))
ReturnFalse;
//---
if(!cCrossLowLevel.UpdateInputWeights(cLowLevelReflection[0].AsObject(),
cLowLevelReflection[1].getOutput()))
ReturnFalse;
//---
if(!cLowLevelReflection[0].UpdateInputWeights(cMarketIntelligence.AsObject()))
ReturnFalse;
if(!cLowLevelReflection[1].UpdateInputWeights(cTransposeState.AsObject()))
ReturnFalse;
//---
if(!cHighLevelReflection.UpdateInputWeights(cMarketIntelligence.AsObject(), SecondInput))
ReturnFalse;
//---
if(!cMarketIntelligence.UpdateInputWeights(NeuronOCL))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinAgent::Save(const int file_handle)
{
if(!CNeuronRelativeCrossAttention::Save(file_handle))
ReturnFalse;
if(!cMarketIntelligence.Save(file_handle))
ReturnFalse;
if(!cMarketMemory.Save(file_handle))
ReturnFalse;
if(!cTransposeState.Save(file_handle))
ReturnFalse;
for(uint i = 0; i < cLowLevelReflection.Size(); i++)
if(!cLowLevelReflection[i].Save(file_handle))
ReturnFalse;
if(!cHighLevelReflection.Save(file_handle))
ReturnFalse;
if(!cTools.Save(file_handle))
ReturnFalse;
if(!cCrossLowLevel.Save(file_handle))
ReturnFalse;
if(!cMarketToLowLevel.Save(file_handle))
ReturnFalse;
if(!cMarketToTools.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinAgent::Load(const int file_handle)
{
if(!CNeuronRelativeCrossAttention::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cMarketIntelligence.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cMarketMemory.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cTransposeState.AsObject()))
ReturnFalse;
for(uint i = 0; i < cLowLevelReflection.Size(); i++)
if(!LoadInsideLayer(file_handle, cLowLevelReflection[i].AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cHighLevelReflection.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cTools.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cCrossLowLevel.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cMarketToLowLevel.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cMarketToTools.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronFinAgent::SetOpenCL(COpenCLMy * obj)
{
CNeuronRelativeCrossAttention::SetOpenCL(obj);
cMarketIntelligence.SetOpenCL(OpenCL);
cMarketMemory.SetOpenCL(OpenCL);
cTransposeState.SetOpenCL(OpenCL);
for(uint i = 0; i < cLowLevelReflection.Size(); i++)
cLowLevelReflection[i].SetOpenCL(OpenCL);
cHighLevelReflection.SetOpenCL(OpenCL);
cTools.SetOpenCL(OpenCL);
cCrossLowLevel.SetOpenCL(OpenCL);
cMarketToLowLevel.SetOpenCL(OpenCL);
cMarketToTools.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinAgent::Clear(void)
{
if(!CNeuronRelativeCrossAttention::Clear())
ReturnFalse;
if(!cMarketIntelligence.Clear())
ReturnFalse;
if(!cMarketMemory.Clear())
ReturnFalse;
if(!cTransposeState.Clear())
ReturnFalse;
for(uint i = 0; i < cLowLevelReflection.Size(); i++)
if(!cLowLevelReflection[i].Clear())
ReturnFalse;
if(!cHighLevelReflection.Clear())
ReturnFalse;
if(!cTools.Clear())
ReturnFalse;
if(!cCrossLowLevel.Clear())
ReturnFalse;
if(!cMarketToLowLevel.Clear())
ReturnFalse;
if(!cMarketToTools.Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemoryDistil::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count,
uint heads, uint stack_size,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronRelativeCrossAttention::Init(numOutputs, myIndex, open_cl, window, window_key,
units_count, heads, window, 2 * stack_size, optimization_type, batch))
ReturnFalse;
//---
uint index = 0;
if(!cLSTM.Init(0, index, OpenCL, iWindow, iUnits, optimization, iBatch))
ReturnFalse;
index++;
if(!cMamba.Init(0, index, OpenCL, iWindow, 2 * iWindow, iUnits, optimization, iBatch))
ReturnFalse;
//---
index++;
if(!cConcatenated.Init(0, index, OpenCL, 2 * iWindow * iUnits, optimization, iBatch))
ReturnFalse;
cConcatenated.SetActivationFunction(None);
index++;
if(!cTransposeConc.Init(0, index, OpenCL, iUnits, 2 * iWindow, optimization, iBatch))
ReturnFalse;
index++;
if(!cConvolution.Init(0, index, OpenCL, iUnits, iUnits, iWindowKey, iWindow, 1, optimization, iBatch))
ReturnFalse;
cConvolution.SetActivationFunction(GELU);
index++;
uint windows[] = {iWindowKey * iWindow, iWindowKey * iWindow};
if(!cDistilMemory.Init(0, index, OpenCL, iUnitsKV / 2, iWindow, windows))
ReturnFalse;
//---
index++;
if(!cCrossAttention.Init(0, index, OpenCL, iWindow, iWindowKey, iUnits, iHeads, iWindow, 2 * iUnits, optimization, iBatch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemoryDistil::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!cLSTM.FeedForward(NeuronOCL))
ReturnFalse;
if(!cMamba.FeedForward(NeuronOCL))
ReturnFalse;
//---
if(!Concat(cLSTM.getOutput(), cMamba.getOutput(), cConcatenated.getOutput(), iWindow, iWindow, iUnits))
ReturnFalse;
if(!cTransposeConc.FeedForward(cConcatenated.AsObject()))
ReturnFalse;
if(!cConvolution.FeedForward(cTransposeConc.AsObject()))
ReturnFalse;
if(!cDistilMemory.FeedForward(cConvolution.AsObject()))
ReturnFalse;
//---
if(!cCrossAttention.FeedForward(NeuronOCL, cConcatenated.getOutput()))
ReturnFalse;
//---
return CNeuronRelativeCrossAttention::feedForward(cCrossAttention.AsObject(), cDistilMemory.getOutput());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemoryDistil::calcInputGradients(CNeuronBaseOCL* NeuronOCL)
{
if(!NeuronOCL)
ReturnFalse;
//---
if(!CNeuronRelativeCrossAttention::calcInputGradients(cCrossAttention.AsObject(),
cDistilMemory.getOutput(),
cDistilMemory.getGradient(),
(ENUM_ACTIVATION)cDistilMemory.Activation()))
ReturnFalse;
//---
if(!cConvolution.CalcHiddenGradients(cDistilMemory.AsObject()))
ReturnFalse;
if(!cTransposeConc.CalcHiddenGradients(cConvolution.AsObject()))
ReturnFalse;
if(!cConcatenated.CalcHiddenGradients(cTransposeConc.AsObject()))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cCrossAttention.AsObject(),
cConcatenated.getOutput(),
cConcatenated.getPrevOutput(),
(ENUM_ACTIVATION)cConcatenated.Activation()))
ReturnFalse;
if(!SumAndNormalize(cConcatenated.getGradient(), cConcatenated.getPrevOutput(),
cConcatenated.getGradient(), iWindow, false, 0, 0, 0, 1) ||
!DeConcat(cLSTM.getGradient(), cMamba.getGradient(), cConcatenated.getGradient(),
iWindow, iWindow, iUnits))
ReturnFalse;
//---
if(cLSTM.Activation() != None)
if(!DeActivation(cLSTM.getOutput(), cLSTM.getGradient(), cLSTM.getGradient(), cLSTM.Activation()))
ReturnFalse;
if(cMamba.Activation() != None)
if(!DeActivation(cMamba.getOutput(), cMamba.getGradient(), cMamba.getGradient(), cMamba.Activation()))
ReturnFalse;
//---
CBufferFloat *temp = NeuronOCL.getGradient();
if(!NeuronOCL.SetGradient(cConcatenated.getPrevOutput(), false) ||
!NeuronOCL.CalcHiddenGradients(cLSTM.AsObject()) ||
!SumAndNormalize(temp, NeuronOCL.getGradient(), temp, iWindow, false, 0, 0, 0, 1))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cMamba.AsObject()) ||
!SumAndNormalize(temp, NeuronOCL.getGradient(), temp, iWindow, false, 0, 0, 0, 1) ||
!NeuronOCL.SetGradient(temp, false))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemoryDistil::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
if(!CNeuronRelativeCrossAttention::updateInputWeights(cCrossAttention.AsObject(), cDistilMemory.getOutput()))
ReturnFalse;
if(!cCrossAttention.UpdateInputWeights(NeuronOCL, cConcatenated.getOutput()))
ReturnFalse;
//---
if(!cDistilMemory.UpdateInputWeights(cConvolution.AsObject()))
ReturnFalse;
if(!cConvolution.UpdateInputWeights(cTransposeConc.AsObject()))
ReturnFalse;
//---
if(!cLSTM.UpdateInputWeights(NeuronOCL))
ReturnFalse;
if(!cMamba.UpdateInputWeights(NeuronOCL))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronMemoryDistil::SetOpenCL(COpenCLMy * obj)
{
CNeuronMemory::SetOpenCL(obj);
cConcatenated.SetOpenCL(OpenCL);
cTransposeConc.SetOpenCL(OpenCL);
cConvolution.SetOpenCL(OpenCL);
cDistilMemory.SetOpenCL(OpenCL);
cCrossAttention.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemoryDistil::Clear(void)
{
if(!CNeuronMemory::Clear())
ReturnFalse;
if(!cConcatenated.Clear())
ReturnFalse;
if(!cTransposeConc.Clear())
ReturnFalse;
if(!cConvolution.Clear())
ReturnFalse;
if(!cDistilMemory.Clear())
ReturnFalse;
if(!cCrossAttention.Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemoryDistil::Save(const int file_handle)
{
if(!CNeuronMemory::Save(file_handle))
ReturnFalse;
if(!cConcatenated.Save(file_handle))
ReturnFalse;
if(!cTransposeConc.Save(file_handle))
ReturnFalse;
if(!cConvolution.Save(file_handle))
ReturnFalse;
if(!cDistilMemory.Save(file_handle))
ReturnFalse;
if(!cCrossAttention.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMemoryDistil::Load(const int file_handle)
{
if(!CNeuronMemory::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cConcatenated.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cTransposeConc.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cConvolution.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cDistilMemory.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cCrossAttention.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConAgent::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count,
uint heads, uint stack_size, uint action_space,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronRelativeCrossAttention::Init(numOutputs, myIndex, open_cl,
3, window_key, action_space / 3,
heads, window, units_count,
optimization_type, batch))
ReturnFalse;
//---
int index = 0;
if(!cStatesMemory.Init(0, index, OpenCL, window, iWindowKey, iUnitsKV,
iHeads, stack_size, optimization, iBatch))
ReturnFalse;
index++;
if(!cActionsMemory.Init(0, index, OpenCL, iWindow, iWindowKey, iUnits,
iHeads, stack_size, optimization, iBatch))
ReturnFalse;
index++;
if(!caRole[0].Init(10 * iWindow, index, OpenCL, 1, optimization, iBatch))
ReturnFalse;
CBufferFloat *out = caRole[0].getOutput();
if(!out ||
!out.Fill(1))
ReturnFalse;
index++;
if(!caRole[1].Init(0, index, OpenCL, 10 * iWindow, optimization, iBatch))
ReturnFalse;
index++;
if(!cStateToRole.Init(0, index, OpenCL, window, iWindowKey, iUnitsKV,
iHeads, iWindow, 10, optimization, iBatch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConAgent::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(bTrain && !caRole[1].FeedForward(caRole[0].AsObject()))
ReturnFalse;
//---
if(!cStateToRole.FeedForward(NeuronOCL, caRole[1].getOutput()))
ReturnFalse;
if(!cStatesMemory.FeedForward(cStateToRole.AsObject()))
ReturnFalse;
//---
if(!cActionsMemory.FeedForward(this.AsObject()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
//---
return CNeuronRelativeCrossAttention::feedForward(cActionsMemory.AsObject(), cStatesMemory.getOutput());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConAgent::calcInputGradients(CNeuronBaseOCL* NeuronOCL)
{
if(!NeuronOCL)
ReturnFalse;
//---
if(!CNeuronRelativeCrossAttention::calcInputGradients(cActionsMemory.AsObject(),
cStatesMemory.getOutput(),
cStatesMemory.getGradient(),
(ENUM_ACTIVATION)cStatesMemory.Activation()))
ReturnFalse;
//---
CBufferFloat *temp = Gradient;
if(!SwapBuffers(Output, PrevOutput) ||
!SetGradient(cActionsMemory.getPrevOutput(), false))
ReturnFalse;
if(!calcHiddenGradients(cActionsMemory.AsObject()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
Gradient = temp;
//---
if(!cStateToRole.CalcHiddenGradients(cStatesMemory.AsObject()))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cStateToRole.AsObject(),
caRole[1].getOutput(),
caRole[1].getGradient(),
(ENUM_ACTIVATION)caRole[1].Activation()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConAgent::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
if(!CNeuronRelativeCrossAttention::updateInputWeights(cActionsMemory.AsObject(),
cStatesMemory.getOutput()))
ReturnFalse;
//---
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
if(!cActionsMemory.UpdateInputWeights(this.AsObject()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
//---
if(!cStatesMemory.UpdateInputWeights(cStateToRole.AsObject()))
ReturnFalse;
if(!cStateToRole.UpdateInputWeights(NeuronOCL, caRole[1].getOutput()))
ReturnFalse;
//---
if(!caRole[1].UpdateInputWeights(caRole[0].AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronFinConAgent::SetOpenCL(COpenCLMy * obj)
{
CNeuronRelativeCrossAttention::SetOpenCL(obj);
cStatesMemory.SetOpenCL(OpenCL);
cActionsMemory.SetOpenCL(OpenCL);
caRole[0].SetOpenCL(OpenCL);
caRole[1].SetOpenCL(OpenCL);
cStateToRole.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConAgent::Clear(void)
{
if(!CNeuronRelativeCrossAttention::Clear())
ReturnFalse;
if(!cStatesMemory.Clear())
ReturnFalse;
if(!cActionsMemory.Clear())
ReturnFalse;
if(!caRole[0].Clear())
ReturnFalse;
if(!caRole[1].Clear())
ReturnFalse;
if(!cStateToRole.Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConAgent::Save(const int file_handle)
{
if(!CNeuronRelativeCrossAttention::Save(file_handle))
ReturnFalse;
if(!cStatesMemory.Save(file_handle))
ReturnFalse;
if(!cActionsMemory.Save(file_handle))
ReturnFalse;
if(!caRole[0].Save(file_handle))
ReturnFalse;
if(!caRole[1].Save(file_handle))
ReturnFalse;
if(!cStateToRole.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConAgent::Load(const int file_handle)
{
if(!CNeuronRelativeCrossAttention::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cStatesMemory.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cActionsMemory.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, caRole[0].AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, caRole[1].AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cStateToRole.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConManager::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count, uint heads,
uint stack_size, uint account_descr, uint action_space,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronFinConAgent::Init(numOutputs, myIndex, open_cl, action_space, window_key,
caAgents.Size() + caTrAgents.Size() + 1,
heads, stack_size, action_space, optimization_type, batch))
ReturnFalse;
//---
int index = 0;
if(!cTransposeState.Init(0, index, OpenCL, units_count, window, optimization, iBatch))
ReturnFalse;
//---
for(uint i = 0; i < caAgents.Size(); i++)
{
index++;
if(!caAgents[i].Init(0, index, OpenCL, window, iWindowKey, units_count, iHeads, stack_size, action_space, optimization, iBatch))
ReturnFalse;
}
for(uint i = 0; i < caTrAgents.Size(); i++)
{
index++;
if(!caTrAgents[i].Init(0, index, OpenCL, units_count, iWindowKey, window, iHeads, stack_size, action_space, optimization, iBatch))
ReturnFalse;
}
index++;
if(!cRiskAgent.Init(0, index, OpenCL, account_descr, iWindowKey, 1, iHeads, stack_size, action_space, optimization, iBatch))
ReturnFalse;
index++;
if(!cConcatenatedAgents.Init(0, index, OpenCL, caAgents.Size()*caAgents[0].Neurons() +
caTrAgents.Size()*caTrAgents[0].Neurons() +
cRiskAgent.Neurons(), optimization, iBatch))
ReturnFalse;
//---
index++;
if(!cAccount.Init(0, index, OpenCL, account_descr, optimization, iBatch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConManager::feedForward(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput)
{
if(cAccount.getOutput() != SecondInput)
{
if(!cAccount.SetOutput(SecondInput, true))
ReturnFalse;
}
if(!cTransposeState.FeedForward(NeuronOCL))
ReturnFalse;
//--- Agents
for(uint i = 0; i < caAgents.Size(); i++)
if(!caAgents[i].FeedForward(NeuronOCL))
ReturnFalse;
for(uint i = 0; i < caTrAgents.Size(); i++)
if(!caTrAgents[i].FeedForward(cTransposeState.AsObject()))
ReturnFalse;
if(!cRiskAgent.FeedForward(cAccount.AsObject()))
ReturnFalse;
//--- Concatenate
if(!Concat(caAgents[0].getOutput(), caAgents[1].getOutput(), caAgents[2].getOutput(), cRiskAgent.getOutput(),
cConcatenatedAgents.getPrevOutput(), Neurons(), Neurons(), Neurons(), Neurons(), 1) ||
!Concat(caTrAgents[0].getOutput(), caTrAgents[1].getOutput(), caTrAgents[2].getOutput(), cConcatenatedAgents.getPrevOutput(),
cConcatenatedAgents.getOutput(), Neurons(), Neurons(), Neurons(), 4 * Neurons(), 1))
ReturnFalse;
//--- Manager
return CNeuronFinConAgent::feedForward(cConcatenatedAgents.AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConManager::calcInputGradients(CNeuronBaseOCL* NeuronOCL,
CBufferFloat* SecondInput,
CBufferFloat* SecondGradient,
ENUM_ACTIVATION SecondActivation = None)
{
if(!NeuronOCL || !SecondGradient)
ReturnFalse;
if(cAccount.getGradient() != SecondGradient)
{
if(!cAccount.SetGradient(SecondGradient, true))
ReturnFalse;
cAccount.SetActivationFunction(SecondActivation);
}
//---
if(!CNeuronFinConAgent::calcInputGradients(cConcatenatedAgents.AsObject()))
ReturnFalse;
//---
if(!DeConcat(caTrAgents[0].getGradient(), caTrAgents[1].getGradient(), caTrAgents[2].getGradient(), cConcatenatedAgents.getPrevOutput(),
cConcatenatedAgents.getGradient(), Neurons(), Neurons(), Neurons(), 4 * Neurons(), 1) ||
!DeConcat(caAgents[0].getGradient(), caAgents[1].getGradient(), caAgents[2].getGradient(), cRiskAgent.getGradient(),
cConcatenatedAgents.getPrevOutput(), Neurons(), Neurons(), Neurons(), Neurons(), 1))
ReturnFalse;
//---
if(!cAccount.CalcHiddenGradients(cRiskAgent.AsObject()))
ReturnFalse;
if(!cTransposeState.CalcHiddenGradients(caTrAgents[0].AsObject()))
ReturnFalse;
CBufferFloat *temp = cTransposeState.getGradient();
if(!cTransposeState.SetGradient(cTransposeState.getPrevOutput(), false))
ReturnFalse;
for(uint i = 1; i < caTrAgents.Size(); i++)
{
if(!cTransposeState.CalcHiddenGradients(caTrAgents[i].AsObject()))
ReturnFalse;
if(!SumAndNormalize(cTransposeState.getGradient(), temp, temp, 1, false, 0, 0, 0, 1))
ReturnFalse;
}
if(!cTransposeState.SetGradient(temp, false))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cTransposeState.AsObject()))
ReturnFalse;
temp = NeuronOCL.getGradient();
if(!NeuronOCL.SetGradient(cTransposeState.getPrevOutput(), false))
ReturnFalse;
for(uint i = 0; i < caAgents.Size(); i++)
{
if(!NeuronOCL.CalcHiddenGradients(caAgents[i].AsObject()))
ReturnFalse;
if(!SumAndNormalize(NeuronOCL.getGradient(), temp, temp, 1, false, 0, 0, 0, 1))
ReturnFalse;
}
if(!NeuronOCL.SetGradient(temp, false))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConManager::updateInputWeights(CNeuronBaseOCL* NeuronOCL,
CBufferFloat* SecondInput)
{
//--- Manager
if(!CNeuronFinConAgent::updateInputWeights(cConcatenatedAgents.AsObject()))
ReturnFalse;
//--- Agents
for(uint i = 0; i < caAgents.Size(); i++)
if(!caAgents[i].UpdateInputWeights(NeuronOCL))
ReturnFalse;
for(uint i = 0; i < caTrAgents.Size(); i++)
if(!caTrAgents[i].UpdateInputWeights(cTransposeState.AsObject()))
ReturnFalse;
if(!cRiskAgent.UpdateInputWeights(cAccount.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronFinConManager::SetOpenCL(COpenCLMy * obj)
{
CNeuronFinConAgent::SetOpenCL(obj);
cTransposeState.SetOpenCL(OpenCL);
for(uint i = 0; i < caAgents.Size(); i++)
caAgents[i].SetOpenCL(OpenCL);
for(uint i = 0; i < caTrAgents.Size(); i++)
caTrAgents[i].SetOpenCL(OpenCL);
cRiskAgent.SetOpenCL(OpenCL);
cConcatenatedAgents.SetOpenCL(OpenCL);
cAccount.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronFinConManager::TrainMode(bool flag)
{
CNeuronFinConAgent::TrainMode(flag);
cTransposeState.TrainMode(flag);
for(uint i = 0; i < caAgents.Size(); i++)
caAgents[i].TrainMode(flag);
for(uint i = 0; i < caTrAgents.Size(); i++)
caTrAgents[i].TrainMode(flag);
cRiskAgent.TrainMode(flag);
cConcatenatedAgents.TrainMode(flag);
cAccount.TrainMode(flag);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConManager::Save(const int file_handle)
{
if(!CNeuronFinConAgent::Save(file_handle))
ReturnFalse;
if(!cTransposeState.Save(file_handle))
ReturnFalse;
for(uint i = 0; i < caAgents.Size(); i++)
if(!caAgents[i].Save(file_handle))
ReturnFalse;
for(uint i = 0; i < caTrAgents.Size(); i++)
if(!caTrAgents[i].Save(file_handle))
ReturnFalse;
if(!cRiskAgent.Save(file_handle))
ReturnFalse;
if(!cConcatenatedAgents.Save(file_handle))
ReturnFalse;
if(!cAccount.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConManager::Load(const int file_handle)
{
if(!CNeuronFinConAgent::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cTransposeState.AsObject()))
ReturnFalse;
for(uint i = 0; i < caAgents.Size(); i++)
if(!LoadInsideLayer(file_handle, caAgents[i].AsObject()))
ReturnFalse;
for(uint i = 0; i < caTrAgents.Size(); i++)
if(!LoadInsideLayer(file_handle, caTrAgents[i].AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cRiskAgent.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cConcatenatedAgents.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cAccount.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronFinConManager::Clear(void)
{
if(!CNeuronFinConAgent::Clear())
ReturnFalse;
if(!cTransposeState.Clear())
ReturnFalse;
for(uint i = 0; i < caAgents.Size(); i++)
if(!caAgents[i].Clear())
ReturnFalse;
for(uint i = 0; i < caTrAgents.Size(); i++)
if(!caTrAgents[i].Clear())
ReturnFalse;
if(!cRiskAgent.Clear())
ReturnFalse;
if(!cConcatenatedAgents.Clear())
ReturnFalse;
if(!cAccount.Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTHyperAgent::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count,
uint heads, uint layers, uint agents, uint stack_size,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronSoftMaxOCL::Init(numOutputs, myIndex, open_cl, agents, optimization_type, batch))
ReturnFalse;
SetHeads(1);
//---
int index = 0;
if(!cMemory.Init(0, 0, OpenCL, window, window_key, units_count, heads, stack_size, optimization, iBatch))
ReturnFalse;
index++;
if(!cStatePrepare.Init(0, index, OpenCL, window, window_key, units_count, heads, layers,
optimization, iBatch))
ReturnFalse;
index++;
if(!cTranspose.Init(0, index, OpenCL, units_count, window, optimization, iBatch))
ReturnFalse;
index++;
if(!cScale.Init(4 * agents, index, OpenCL, 3, 1, 1, units_count - 2, window, optimization, iBatch))
ReturnFalse;
cScale.SetActivationFunction(TANH);
index++;
if(!cMLP[0].Init(agents, index, OpenCL, 4 * agents, optimization, iBatch))
ReturnFalse;
cMLP[0].SetActivationFunction(LReLU);
index++;
if(!cMLP[1].Init(0, index, OpenCL, agents, optimization, iBatch))
ReturnFalse;
cMLP[0].SetActivationFunction(None);
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTHyperAgent::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!cMemory.FeedForward(NeuronOCL))
ReturnFalse;
if(!cStatePrepare.FeedForward(cMemory.AsObject()))
ReturnFalse;
if(!cTranspose.FeedForward(cStatePrepare.AsObject()))
ReturnFalse;
if(!cScale.FeedForward(cTranspose.AsObject()))
ReturnFalse;
if(!cMLP[0].FeedForward(cScale.AsObject()))
ReturnFalse;
if(!cMLP[1].FeedForward(cMLP[0].AsObject()))
ReturnFalse;
//---
return CNeuronSoftMaxOCL::feedForward(cMLP[1].AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTHyperAgent::calcInputGradients(CNeuronBaseOCL* NeuronOCL)
{
if(!NeuronOCL)
ReturnFalse;
if(!CNeuronSoftMaxOCL::calcInputGradients(cMLP[1].AsObject()))
ReturnFalse;
if(!cMLP[0].CalcHiddenGradients(cMLP[1].AsObject()))
ReturnFalse;
if(!cScale.CalcHiddenGradients(cMLP[0].AsObject()))
ReturnFalse;
if(!cTranspose.CalcHiddenGradients(cScale.AsObject()))
ReturnFalse;
if(!cStatePrepare.CalcHiddenGradients(cTranspose.AsObject()))
ReturnFalse;
if(!cMemory.CalcHiddenGradients(cStatePrepare.AsObject()))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cMemory.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTHyperAgent::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
if(!cMLP[1].UpdateInputWeights(cMLP[0].AsObject()))
ReturnFalse;
if(!cMLP[0].UpdateInputWeights(cScale.AsObject()))
ReturnFalse;
if(!cScale.UpdateInputWeights(cTranspose.AsObject()))
ReturnFalse;
if(!cStatePrepare.UpdateInputWeights(cMemory.AsObject()))
ReturnFalse;
if(!cMemory.UpdateInputWeights(NeuronOCL))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTHyperAgent::Save(const int file_handle)
{
if(!CNeuronSoftMaxOCL::Save(file_handle))
ReturnFalse;
if(!cStatePrepare.Save(file_handle))
ReturnFalse;
if(!cTranspose.Save(file_handle))
ReturnFalse;
if(!cScale.Save(file_handle))
ReturnFalse;
for(uint i = 0; i < cMLP.Size(); i++)
if(!cMLP[i].Save(file_handle))
ReturnFalse;
if(!cMemory.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTHyperAgent::Load(const int file_handle)
{
if(!CNeuronSoftMaxOCL::Load(file_handle))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cStatePrepare.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cTranspose.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cScale.AsObject()))
ReturnFalse;
for(uint i = 0; i < cMLP.Size(); i++)
if(!LoadInsideLayer(file_handle, cMLP[i].AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cMemory.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronMacroHFTHyperAgent::SetOpenCL(COpenCLMy * obj)
{
CNeuronSoftMaxOCL::SetOpenCL(obj);
cStatePrepare.SetOpenCL(obj);
cTranspose.SetOpenCL(obj);
cScale.SetOpenCL(obj);
for(uint i = 0; i < cMLP.Size(); i++)
cMLP[i].SetOpenCL(obj);
cMemory.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTHyperAgent::Clear(void)
{
if(!CNeuronSoftMaxOCL::Clear())
ReturnFalse;
if(!cStatePrepare.Clear())
ReturnFalse;
if(!cTranspose.Clear())
ReturnFalse;
if(!cScale.Clear())
ReturnFalse;
for(uint i = 0; i < cMLP.Size(); i++)
if(!cMLP[i].Clear())
ReturnFalse;
if(!cMemory.Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFT::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count,
uint heads, uint layers, uint stack_size, uint nactions,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, nactions, optimization_type, batch))
ReturnFalse;
//---
int index = 0;
if(!cTranspose.Init(0, index, OpenCL, units_count, window, optimization, iBatch))
ReturnFalse;
uint half = (caAgents.Size() + 1) / 2;
for(uint i = 0; i < half; i++)
{
index++;
if(!caAgents[i].Init(0, index, OpenCL, window, window_key, units_count, heads,
stack_size, nactions, optimization, iBatch))
ReturnFalse;
}
for(uint i = half; i < caAgents.Size(); i++)
{
index++;
if(!caAgents[i].Init(0, index, OpenCL, units_count, window_key, window, heads,
stack_size, nactions, optimization, iBatch))
ReturnFalse;
}
index++;
if(!cHyperAgent.Init(0, index, OpenCL, window, window_key, units_count, heads, layers,
caAgents.Size(), stack_size, optimization, iBatch))
ReturnFalse;
index++;
if(!cConcatenated.Init(0, index, OpenCL, caAgents.Size()*nactions, optimization, iBatch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFT::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(!cTranspose.FeedForward(NeuronOCL))
ReturnFalse;
//---
uint total = caAgents.Size();
uint half = (total + 1) / 2;
for(uint i = 0; i < half; i++)
if(!caAgents[i].FeedForward(NeuronOCL))
ReturnFalse;
for(uint i = half; i < total; i++)
if(!caAgents[i].FeedForward(cTranspose.AsObject()))
ReturnFalse;
if(!cHyperAgent.FeedForward(NeuronOCL))
ReturnFalse;
//---
if(!Concat(caAgents[0].getOutput(), caAgents[1].getOutput(), caAgents[2].getOutput(),
caAgents[3].getOutput(), cConcatenated.getPrevOutput(), Neurons(), Neurons(),
Neurons(), Neurons(), 1) ||
!Concat(cConcatenated.getPrevOutput(), caAgents[4].getOutput(), caAgents[5].getOutput(),
cConcatenated.getOutput(), 4 * Neurons(), Neurons(), Neurons(), 1))
ReturnFalse;
if(!MatMul(cHyperAgent.getOutput(), cConcatenated.getOutput(), Output, 1, total, Neurons(), 1))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFT::calcInputGradients(CNeuronBaseOCL* NeuronOCL)
{
if(!NeuronOCL)
ReturnFalse;
//---
uint total = caAgents.Size();
if(!MatMulGrad(cHyperAgent.getOutput(), cHyperAgent.getGradient(), cConcatenated.getOutput(), cConcatenated.getGradient(), Gradient, 1, total, Neurons(), 1))
ReturnFalse;
//---
if(!NeuronOCL.CalcHiddenGradients(cHyperAgent.AsObject()))
ReturnFalse;
//---
if(!DeConcat(cConcatenated.getPrevOutput(), caAgents[4].getGradient(), caAgents[5].getGradient(),
cConcatenated.getGradient(), 4 * Neurons(), Neurons(), Neurons(), 1) ||
!DeConcat(caAgents[0].getGradient(), caAgents[1].getGradient(), caAgents[2].getGradient(),
caAgents[3].getGradient(), cConcatenated.getPrevOutput(), Neurons(), Neurons(),
Neurons(), Neurons(), 1))
ReturnFalse;
//---
CBufferFloat *temp = NeuronOCL.getGradient();
if(!temp ||
!NeuronOCL.SetGradient(cTranspose.getPrevOutput(), false))
ReturnFalse;
uint half = (total + 1) / 2;
for(uint i = 0; i < half; i++)
{
if(!NeuronOCL.CalcHiddenGradients(caAgents[i].AsObject()))
ReturnFalse;
if(!SumAndNormalize(temp, NeuronOCL.getGradient(), temp, 1, false, 0, 0, 0, 1))
ReturnFalse;
}
for(uint i = half; i < total; i++)
{
if(!cTranspose.CalcHiddenGradients(caAgents[i].AsObject()) ||
!NeuronOCL.CalcHiddenGradients(cTranspose.AsObject()))
ReturnFalse;
if(!SumAndNormalize(temp, NeuronOCL.getGradient(), temp, 1, false, 0, 0, 0, 1))
ReturnFalse;
}
if(!NeuronOCL.SetGradient(temp, false))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFT::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
if(!cHyperAgent.UpdateInputWeights(NeuronOCL))
ReturnFalse;
//---
uint total = caAgents.Size();
uint half = (total + 1) / 2;
for(uint i = 0; i < half; i++)
if(!caAgents[i].UpdateInputWeights(NeuronOCL))
ReturnFalse;
for(uint i = half; i < total; i++)
if(!caAgents[i].UpdateInputWeights(cTranspose.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFT::Save(const int file_handle)
{
if(!CNeuronBaseOCL::Save(file_handle))
ReturnFalse;
//---
if(!cTranspose.Save(file_handle))
ReturnFalse;
for(uint i = 0; i < caAgents.Size(); i++)
if(!caAgents[i].Save(file_handle))
ReturnFalse;
if(!cHyperAgent.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFT::Load(const int file_handle)
{
if(!CNeuronBaseOCL::Load(file_handle))
ReturnFalse;
//---
if(!LoadInsideLayer(file_handle, cTranspose.AsObject()))
ReturnFalse;
for(uint i = 0; i < caAgents.Size(); i++)
if(!LoadInsideLayer(file_handle, caAgents[i].AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cHyperAgent.AsObject()))
ReturnFalse;
//---
if(!cConcatenated.Init(0, 8, OpenCL, caAgents.Size()*Neurons(), optimization, iBatch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronMacroHFT::SetOpenCL(COpenCLMy * obj)
{
CNeuronBaseOCL::SetOpenCL(obj);
//---
cTranspose.SetOpenCL(obj);
for(uint i = 0; i < caAgents.Size(); i++)
caAgents[i].SetOpenCL(obj);
cHyperAgent.SetOpenCL(obj);
cConcatenated.SetOpenCL(obj);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFT::Clear(void)
{
if(!CNeuronBaseOCL::Clear())
ReturnFalse;
//---
if(!cTranspose.Clear())
ReturnFalse;
for(uint i = 0; i < caAgents.Size(); i++)
if(!caAgents[i].Clear())
ReturnFalse;
if(!cHyperAgent.Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTvsRiskManager::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count, uint heads,
uint stack_size, uint nactions, uint account_decr,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CResidualConv::Init(numOutputs, myIndex, open_cl, 3, 3, (nactions + 2) / 3, optimization_type, batch))
ReturnFalse;
//---
int index = 0;
if(!caAccountProjection[0].Init(0, index, OpenCL, account_decr, optimization, iBatch))
ReturnFalse;
index++;
if(!caAccountProjection[1].Init(0, index, OpenCL, window * units_count, optimization, iBatch))
ReturnFalse;
index++;
if(!cMemoryAccount.Init(caAccountProjection[1].Neurons(), index, OpenCL, account_decr,
window_key, 1, heads, stack_size, optimization, iBatch))
ReturnFalse;
index++;
if(!cMemoryAction.Init(0, index, OpenCL, 3, window_key, (nactions + 2) / 3,
heads, stack_size, optimization, iBatch))
ReturnFalse;
index++;
if(!cCrossAttention.Init(0, index, OpenCL, 3, window_key, (nactions + 2) / 3,
heads, window, units_count, optimization, iBatch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTvsRiskManager::feedForward(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput)
{
if(caAccountProjection[0].getOutput() != SecondInput)
{
if(!caAccountProjection[0].SetOutput(SecondInput, true))
ReturnFalse;
}
//---
if(!cMemoryAccount.FeedForward(caAccountProjection[0].AsObject()))
ReturnFalse;
if(!caAccountProjection[1].FeedForward(cMemoryAccount.AsObject()))
ReturnFalse;
if(!cMemoryAction.FeedForward(NeuronOCL))
ReturnFalse;
if(!cCrossAttention.FeedForward(cMemoryAction.AsObject(), caAccountProjection[1].getOutput()))
ReturnFalse;
//---
return CResidualConv::feedForward(cCrossAttention.AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTvsRiskManager::calcInputGradients(CNeuronBaseOCL* NeuronOCL,
CBufferFloat* SecondInput,
CBufferFloat* SecondGradient,
ENUM_ACTIVATION SecondActivation = None)
{
if(!NeuronOCL || !SecondGradient)
ReturnFalse;
if(caAccountProjection[0].getGradient() != SecondGradient)
{
if(!caAccountProjection[0].SetGradient(SecondGradient, true))
ReturnFalse;
caAccountProjection[0].SetActivationFunction(SecondActivation);
}
//---
if(!CResidualConv::calcInputGradients(cCrossAttention.AsObject()))
ReturnFalse;
if(!cMemoryAction.CalcHiddenGradients(cCrossAttention.AsObject(),
caAccountProjection[1].getOutput(),
caAccountProjection[1].getGradient(),
(ENUM_ACTIVATION)caAccountProjection[1].Activation()))
ReturnFalse;
//---
if(!NeuronOCL.CalcHiddenGradients(cMemoryAction.AsObject()))
ReturnFalse;
//---
if(!cMemoryAccount.CalcHiddenGradients(caAccountProjection[1].AsObject()))
ReturnFalse;
if(!caAccountProjection[0].CalcHiddenGradients(cMemoryAccount.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTvsRiskManager::updateInputWeights(CNeuronBaseOCL* NeuronOCL,
CBufferFloat* SecondInput)
{
if(!CResidualConv::updateInputWeights(cCrossAttention.AsObject()))
ReturnFalse;
if(!cCrossAttention.UpdateInputWeights(cMemoryAction.AsObject(), caAccountProjection[1].getOutput()))
ReturnFalse;
//---
if(!cMemoryAction.UpdateInputWeights(NeuronOCL))
ReturnFalse;
//---
if(!caAccountProjection[1].UpdateInputWeights(cMemoryAccount.AsObject()))
ReturnFalse;
if(!cMemoryAccount.UpdateInputWeights(caAccountProjection[0].AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTvsRiskManager::Save(const int file_handle)
{
if(!CResidualConv::Save(file_handle))
ReturnFalse;
for(uint i = 0; i < caAccountProjection.Size(); i++)
if(!caAccountProjection[i].Save(file_handle))
ReturnFalse;
if(!cMemoryAccount.Save(file_handle))
ReturnFalse;
if(!cMemoryAction.Save(file_handle))
ReturnFalse;
if(!cCrossAttention.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTvsRiskManager::Load(const int file_handle)
{
if(!CResidualConv::Load(file_handle))
ReturnFalse;
for(uint i = 0; i < caAccountProjection.Size(); i++)
if(!LoadInsideLayer(file_handle, caAccountProjection[i].AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cMemoryAccount.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cMemoryAction.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cCrossAttention.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronMacroHFTvsRiskManager::SetOpenCL(COpenCLMy * obj)
{
CResidualConv::SetOpenCL(obj);
for(uint i = 0; i < caAccountProjection.Size(); i++)
caAccountProjection[i].SetOpenCL(OpenCL);
cMemoryAccount.SetOpenCL(OpenCL);
cMemoryAction.SetOpenCL(OpenCL);
cCrossAttention.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronMacroHFTvsRiskManager::Clear(void)
{
if(!CResidualConv::Clear())
ReturnFalse;
for(uint i = 0; i < caAccountProjection.Size(); i++)
if(!caAccountProjection[i].Clear())
ReturnFalse;
if(!cMemoryAccount.Clear())
ReturnFalse;
if(!cMemoryAction.Clear())
ReturnFalse;
if(!cCrossAttention.Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerTSAgent::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint window_key, uint units_count,
uint heads, uint stack_size, uint action_space,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CResidualConv::Init(numOutputs, myIndex, open_cl, 3, 3, (action_space + 2) / 3, optimization_type, batch))
ReturnFalse;
//--- Role
int index = 0;
if(!caRole[0].Init(10 * window_key, index, OpenCL, 1, optimization, iBatch))
ReturnFalse;
caRole[0].getOutput().Fill(1);
index++;
if(!caRole[1].Init(0, index, OpenCL, 10 * window_key, optimization, iBatch))
ReturnFalse;
//--- State to Role
index++;
if(!cStateToRole.Init(0, index, OpenCL, window, window_key, units_count, heads, window_key, 10, optimization, iBatch))
ReturnFalse;
//--- State
index++;
if(!cShuffle.Init(0, index, OpenCL, window, window * units_count, optimization, iBatch))
ReturnFalse;
index++;
if(!cRecursiveState.Init(0, index, OpenCL, window, window_key, units_count, heads, stack_size, optimization, iBatch))
ReturnFalse;
index++;
if(!cResidualState.Init(0, index, OpenCL, window, window, units_count, optimization, iBatch))
ReturnFalse;
//--- Action
index++;
if(!cRecursiveAction.Init(0, index, OpenCL, 3, window_key, (action_space + 2) / 3, heads, stack_size, optimization, iBatch))
ReturnFalse;
index++;
if(!cActionToState.Init(0, index, OpenCL, 3, window_key, (action_space + 2) / 3, heads, window, units_count, optimization, iBatch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerTSAgent::feedForward(CNeuronBaseOCL* NeuronOCL)
{
if(bTrain && !caRole[1].FeedForward(caRole[0].AsObject()))
ReturnFalse;
//--- State to Role
if(!cStateToRole.FeedForward(NeuronOCL, caRole[1].getOutput()))
ReturnFalse;
//--- State
if(!cShuffle.FeedForward(cStateToRole.AsObject()))
ReturnFalse;
if(!cRecursiveState.FeedForward(cShuffle.AsObject()))
ReturnFalse;
if(!cResidualState.FeedForward(cRecursiveState.AsObject()))
ReturnFalse;
//--- Action
if(!cRecursiveAction.FeedForward(AsObject()))
ReturnFalse;
if(!cActionToState.FeedForward(cRecursiveAction.AsObject(), cResidualState.getOutput()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
//---
return CResidualConv::feedForward(cActionToState.AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerTSAgent::calcInputGradients(CNeuronBaseOCL* NeuronOCL)
{
if(!NeuronOCL)
ReturnFalse;
//---
if(!CResidualConv::calcInputGradients(cActionToState.AsObject()))
ReturnFalse;
if(!cRecursiveAction.CalcHiddenGradients(cActionToState.AsObject(),
cResidualState.getOutput(),
cResidualState.getGradient(),
(ENUM_ACTIVATION)cResidualState.Activation()))
ReturnFalse;
//--- Action
CBufferFloat *temp = Gradient;
if(!SwapBuffers(Output, PrevOutput) ||
!SetGradient(cRecursiveAction.getPrevOutput(), false))
ReturnFalse;
if(!calcHiddenGradients(cRecursiveAction.AsObject()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
Gradient = temp;
//--- State
if(!cRecursiveState.CalcHiddenGradients(cResidualState.AsObject()))
ReturnFalse;
if(!cShuffle.CalcHiddenGradients(cRecursiveState.AsObject()))
ReturnFalse;
if(!cStateToRole.CalcHiddenGradients(cShuffle.AsObject()))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cStateToRole.AsObject(),
caRole[1].getOutput(),
caRole[1].getGradient(),
(ENUM_ACTIVATION)caRole[1].Activation()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerTSAgent::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
if(!CResidualConv::updateInputWeights(cActionToState.AsObject()))
ReturnFalse;
//--- Action
if(!cActionToState.UpdateInputWeights(cRecursiveAction.AsObject()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput) ||
!cRecursiveAction.UpdateInputWeights(AsObject()) ||
!SwapBuffers(Output, PrevOutput))
ReturnFalse;
//--- State
if(!cResidualState.UpdateInputWeights(cRecursiveState.AsObject()))
ReturnFalse;
if(!cResidualState.UpdateInputWeights(cShuffle.AsObject()))
ReturnFalse;
if(!cShuffle.UpdateInputWeights(cStateToRole.AsObject()))
ReturnFalse;
if(!cStateToRole.UpdateInputWeights(NeuronOCL, caRole[1].getOutput()))
ReturnFalse;
//--- Role
if(!caRole[1].UpdateInputWeights(caRole[0].AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerTSAgent::Save(const int file_handle)
{
if(!CResidualConv::Save(file_handle))
ReturnFalse;
//---
for(uint i = 0; i < caRole.Size(); i++)
if(!caRole[i].Save(file_handle))
ReturnFalse;
if(!cStateToRole.Save(file_handle))
ReturnFalse;
if(!cShuffle.Save(file_handle))
ReturnFalse;
if(!cRecursiveState.Save(file_handle))
ReturnFalse;
if(!cResidualState.Save(file_handle))
ReturnFalse;
if(!cRecursiveAction.Save(file_handle))
ReturnFalse;
if(!cActionToState.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerTSAgent::Load(const int file_handle)
{
if(!CResidualConv::Load(file_handle))
ReturnFalse;
//---
for(uint i = 0; i < caRole.Size(); i++)
if(!LoadInsideLayer(file_handle, caRole[i].AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cStateToRole.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cShuffle.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cRecursiveState.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cResidualState.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cRecursiveAction.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cActionToState.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronHidformerTSAgent::SetOpenCL(COpenCLMy * obj)
{
CResidualConv::SetOpenCL(obj);
//---
for(uint i = 0; i < caRole.Size(); i++)
caRole[i].SetOpenCL(OpenCL);
cStateToRole.SetOpenCL(OpenCL);
cShuffle.SetOpenCL(OpenCL);
cRecursiveState.SetOpenCL(OpenCL);
cResidualState.SetOpenCL(OpenCL);
cRecursiveAction.SetOpenCL(OpenCL);
cActionToState.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerTSAgent::Clear(void)
{
if(!CResidualConv::Clear())
ReturnFalse;
//---
for(uint i = 0; i < caRole.Size(); i++)
if(!caRole[i].Clear())
ReturnFalse;
if(!cStateToRole.Clear())
ReturnFalse;
if(!cShuffle.Clear())
ReturnFalse;
if(!cRecursiveState.Clear())
ReturnFalse;
if(!cResidualState.Clear())
ReturnFalse;
if(!cRecursiveAction.Clear())
ReturnFalse;
if(!cActionToState.Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerFreqAgent::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint window, uint filters, uint units_count,
uint heads, uint stack_size, uint action_space,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CResidualConv::Init(numOutputs, myIndex, open_cl, 3, 3, (action_space + 2) / 3, optimization_type, batch))
ReturnFalse;
//---
int index = 0;
if(!cTranspose.Init(0, index, OpenCL, units_count, window, optimization, iBatch))
ReturnFalse;
index++;
uint wind = (units_count >= 20 ? (units_count + 3) / 4 : units_count);
uint units = (units_count + wind - 1) / wind;
if(!cLegendre.Init(0, index, OpenCL, wind, wind, units, filters, window, optimization, batch))
ReturnFalse;
index++;
if(!cHLState.Init(0, index, OpenCL, units * window, 2, filters, optimization, iBatch))
ReturnFalse;
index++;
if(!cAttentionState.Init(0, index, OpenCL, filters, filters, units * window, 2, optimization, iBatch))
ReturnFalse;
index++;
if(!cResidualState.Init(0, index, OpenCL, filters, filters, 2 * units * window, optimization, iBatch))
ReturnFalse;
index++;
if(!cShuffle.Init(0, index, OpenCL, filters, cResidualState.Neurons(), optimization, iBatch))
ReturnFalse;
//--- Action
index++;
if(!cRecursiveAction.Init(0, index, OpenCL, 3, filters, (action_space + 2) / 3, heads, stack_size, optimization, iBatch))
ReturnFalse;
index++;
if(!cActionToState.Init(0, index, OpenCL, 3, filters, (action_space + 2) / 3, heads, filters, 2 * units * window, optimization, iBatch))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerFreqAgent::feedForward(CNeuronBaseOCL* NeuronOCL)
{
//--- State
if(!cTranspose.FeedForward(NeuronOCL))
ReturnFalse;
if(!cLegendre.FeedForward(cTranspose.AsObject()))
ReturnFalse;
if(!cHLState.FeedForward(cLegendre.AsObject()))
ReturnFalse;
if(!cAttentionState.FeedForward(cHLState.AsObject()))
ReturnFalse;
if(!cResidualState.FeedForward(cAttentionState.AsObject()))
ReturnFalse;
if(!cShuffle.FeedForward(cResidualState.AsObject()))
ReturnFalse;
//--- Action
if(!cRecursiveAction.FeedForward(AsObject()))
ReturnFalse;
if(!cActionToState.FeedForward(cRecursiveAction.AsObject(), cShuffle.getOutput()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput))
ReturnFalse;
return CResidualConv::feedForward(cActionToState.AsObject());
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerFreqAgent::calcInputGradients(CNeuronBaseOCL* NeuronOCL)
{
if(!NeuronOCL)
ReturnFalse;
//--- Action
if(!CResidualConv::calcInputGradients(cActionToState.AsObject()))
ReturnFalse;
if(!cRecursiveAction.CalcHiddenGradients(cActionToState.AsObject(),
cShuffle.getOutput(),
cShuffle.getGradient(),
(ENUM_ACTIVATION)cShuffle.Activation()))
ReturnFalse;
CBufferFloat *temp = Gradient;
if(!SwapBuffers(Output, PrevOutput) ||
!SetGradient(cActionToState.getPrevOutput(), false) ||
!calcHiddenGradients(cRecursiveAction.AsObject()) ||
!SwapBuffers(Output, PrevOutput))
ReturnFalse;
Gradient = temp;
//--- State
if(!cResidualState.CalcHiddenGradients(cShuffle.AsObject()))
ReturnFalse;
if(!cAttentionState.CalcHiddenGradients(cResidualState.AsObject()))
ReturnFalse;
if(!cHLState.CalcHiddenGradients(cAttentionState.AsObject()))
ReturnFalse;
if(!cLegendre.CalcHiddenGradients(cHLState.AsObject()))
ReturnFalse;
if(!cTranspose.CalcHiddenGradients(cLegendre.AsObject()))
ReturnFalse;
if(!NeuronOCL.CalcHiddenGradients(cTranspose.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerFreqAgent::updateInputWeights(CNeuronBaseOCL* NeuronOCL)
{
//--- Action
if(!CResidualConv::updateInputWeights(cActionToState.AsObject()))
ReturnFalse;
if(!cActionToState.UpdateInputWeights(cRecursiveAction.AsObject(),
cShuffle.getOutput()))
ReturnFalse;
if(!SwapBuffers(Output, PrevOutput) ||
!cRecursiveAction.UpdateInputWeights(AsObject()) ||
!SwapBuffers(Output, PrevOutput))
ReturnFalse;
//--- State
if(!cShuffle.UpdateInputWeights(cResidualState.AsObject()))
ReturnFalse;
if(!cResidualState.UpdateInputWeights(cAttentionState.AsObject()))
ReturnFalse;
if(!cAttentionState.UpdateInputWeights(cHLState.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerFreqAgent::Save(const int file_handle)
{
if(!CResidualConv::Save(file_handle))
ReturnFalse;
//---
if(!cTranspose.Save(file_handle))
ReturnFalse;
if(!cLegendre.Save(file_handle))
ReturnFalse;
if(!cHLState.Save(file_handle))
ReturnFalse;
if(!cAttentionState.Save(file_handle))
ReturnFalse;
if(!cResidualState.Save(file_handle))
ReturnFalse;
if(!cShuffle.Save(file_handle))
ReturnFalse;
//--- Action
if(!cRecursiveAction.Save(file_handle))
ReturnFalse;
if(!cActionToState.Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerFreqAgent::Load(const int file_handle)
{
if(!CResidualConv::Load(file_handle))
ReturnFalse;
//--- State
if(!LoadInsideLayer(file_handle, cTranspose.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cLegendre.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cHLState.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cAttentionState.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cResidualState.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cShuffle.AsObject()))
ReturnFalse;
//--- Action
if(!LoadInsideLayer(file_handle, cRecursiveAction.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cActionToState.AsObject()))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHidformerFreqAgent::Clear(void)
{
if(!CResidualConv::Clear())
ReturnFalse;
//---
if(!cTranspose.Clear())
ReturnFalse;
if(!cLegendre.Clear())
ReturnFalse;
if(!cHLState.Clear())
ReturnFalse;
if(!cAttentionState.Clear())
ReturnFalse;
if(!cResidualState.Clear())
ReturnFalse;
if(!cShuffle.Clear())
ReturnFalse;
//--- Action
if(!cRecursiveAction.Clear())
ReturnFalse;
if(!cActionToState.Clear())
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronHidformerFreqAgent::SetOpenCL(COpenCLMy * obj)
{
CResidualConv::SetOpenCL(obj);
//---
cTranspose.SetOpenCL(OpenCL);
cLegendre.SetOpenCL(OpenCL);
cHLState.SetOpenCL(OpenCL);
cAttentionState.SetOpenCL(OpenCL);
cResidualState.SetOpenCL(OpenCL);
cShuffle.SetOpenCL(OpenCL);
//--- Action
cRecursiveAction.SetOpenCL(OpenCL);
cActionToState.SetOpenCL(OpenCL);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHiSSDLowLevelControler::Init(uint numOutputs, uint myIndex, COpenCLMy * open_cl,
uint time_step, uint variables, uint task_skills,
uint common_skills, uint n_actions, uint window,
uint step, uint window_key, uint heads,
ENUM_OPTIMIZATION optimization_type, uint batch)
{
if(!CNeuronConvOCL::Init(numOutputs, myIndex, open_cl, window_key, window_key,
n_actions, 1, variables, optimization_type, batch))
ReturnFalse;
SetActivationFunction(SIGMOID);
//---
int index = 0;
if(!cTaskSpecificSkillsEncoder.Init(0, index, OpenCL, time_step, variables, task_skills,
window, step, window_key, heads, optimization, iBatch))
ReturnFalse;
cTaskSpecificSkillsEncoder.SetActivationFunction(None);
//---
iTaskSkills = task_skills;
iCommonSkills = MathMax(common_skills, 1);
//---
index++;
if(!cTranspose.Init(0, index, OpenCL, time_step, variables, optimization, iBatch))
ReturnFalse;
//---
uint window_size = (time_step + iTaskSkills + iCommonSkills);
index++;
if(!cObservAndSkillsConcat.Init(0, index, OpenCL, window_size * iVariables,
optimization, iBatch))
ReturnFalse;
cObservAndSkillsConcat.SetActivationFunction(None);
index++;
if(!cNormalizarion.Init(0, index, OpenCL, cObservAndSkillsConcat.Neurons(),
iBatch, optimization))
ReturnFalse;
cNormalizarion.SetActivationFunction(None);
for(uint i = 0; i < cActionDecoder.Size(); i++)
{
index++;
if(!cActionDecoder[i].Init(0, index, OpenCL, window_size, window_size, window_key,
1, iVariables, optimization, iBatch))
ReturnFalse;
cActionDecoder[i].SetActivationFunction(SoftPlus);
window_size = window_key;
}
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHiSSDLowLevelControler::feedForward(CNeuronBaseOCL* NeuronOCL, CBufferFloat* SecondInput)
{
if(!SecondInput)
ReturnFalse;
if(!cTaskSpecificSkillsEncoder.FeedForward(NeuronOCL))
ReturnFalse;
if(!cTranspose.FeedForward(NeuronOCL))
ReturnFalse;
if(!Concat(cTranspose.getOutput(), cTaskSpecificSkillsEncoder.getOutput(), SecondInput,
cObservAndSkillsConcat.getOutput(), cTranspose.GetCount(),
iTaskSkills, iCommonSkills, iVariables))
ReturnFalse;
if(!cNormalizarion.FeedForward(cObservAndSkillsConcat.AsObject()))
ReturnFalse;
CNeuronBaseOCL *neuron = cNormalizarion.AsObject();
for(uint i = 0; i < cActionDecoder.Size(); i++)
{
if(!cActionDecoder[i].FeedForward(neuron))
ReturnFalse;
neuron = cActionDecoder[i].AsObject();
}
//---
return CNeuronConvOCL::feedForward(neuron);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHiSSDLowLevelControler::calcInputGradients(CNeuronBaseOCL* NeuronOCL,
CBufferFloat* SecondInput,
CBufferFloat* SecondGradient,
ENUM_ACTIVATION SecondActivation = None)
{
if(!NeuronOCL || !SecondGradient)
ReturnFalse;
//---
uint total = cActionDecoder.Size();
if(total <= 0)
ReturnFalse;
CObject *neuron = cActionDecoder[total - 1].AsObject();
//---
if(!CNeuronConvOCL::calcInputGradients(neuron))
ReturnFalse;
for(int i = int(total - 2); i >= 0; i--)
{
if(!cActionDecoder[i].CalcHiddenGradients(neuron))
ReturnFalse;
neuron = cActionDecoder[i].AsObject();
}
if(!cNormalizarion.CalcHiddenGradients(neuron))
ReturnFalse;
if(!cObservAndSkillsConcat.CalcHiddenGradients(cNormalizarion.AsObject()))
ReturnFalse;
if(!DeConcat(cTranspose.getGradient(), cTaskSpecificSkillsEncoder.getGradient(), SecondGradient,
cObservAndSkillsConcat.getGradient(), cTranspose.GetCount(),
iTaskSkills, iCommonSkills, iVariables))
ReturnFalse;
//---
if(SecondActivation != None)
{
if(!DeActivation(SecondInput, SecondGradient, SecondGradient, SecondActivation))
ReturnFalse;
}
if(NeuronOCL.Activation() != None)
{
if(!DeActivation(cTranspose.getOutput(), cTranspose.getGradient(),
cTranspose.getGradient(), NeuronOCL.Activation()))
ReturnFalse;
}
if(cTaskSpecificSkillsEncoder.Activation() != None)
{
if(!DeActivation(cTaskSpecificSkillsEncoder.getOutput(), cTaskSpecificSkillsEncoder.getGradient(),
cTaskSpecificSkillsEncoder.getGradient(), cTaskSpecificSkillsEncoder.Activation()))
ReturnFalse;
}
//---
if(!NeuronOCL.CalcHiddenGradients(cTaskSpecificSkillsEncoder.AsObject()))
ReturnFalse;
CBufferFloat *temp = NeuronOCL.getGradient();
if(!NeuronOCL.SetGradient(cTranspose.getPrevOutput(), false) ||
!NeuronOCL.CalcHiddenGradients(cTranspose.AsObject()) ||
!SumAndNormalize(temp, NeuronOCL.getGradient(), temp, iVariables, false, 0, 0, 0, 1) ||
!NeuronOCL.SetGradient(temp, false))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHiSSDLowLevelControler::updateInputWeights(CNeuronBaseOCL* NeuronOCL, CBufferFloat* second)
{
if(!cTaskSpecificSkillsEncoder.UpdateInputWeights(NeuronOCL))
ReturnFalse;
if(!cNormalizarion.UpdateInputWeights(cObservAndSkillsConcat.AsObject()))
ReturnFalse;
CNeuronBaseOCL *neuron = cNormalizarion.AsObject();
for(uint i = 0; i < cActionDecoder.Size(); i++)
{
if(!cActionDecoder[i].UpdateInputWeights(neuron))
ReturnFalse;
neuron = cActionDecoder[i].AsObject();
}
//---
return CNeuronConvOCL::updateInputWeights(neuron);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHiSSDLowLevelControler::WeightsUpdate(CNeuronBaseOCL* source, float tau)
{
if(!source || source.Type() != Type())
ReturnFalse;
CNeuronHiSSDLowLevelControler *Source = source;
if(!cTaskSpecificSkillsEncoder.WeightsUpdate(GetPointer(Source.cTaskSpecificSkillsEncoder), tau))
ReturnFalse;
if(!cNormalizarion.WeightsUpdate(GetPointer(Source.cNormalizarion), tau))
ReturnFalse;
for(uint i = 0; i < cActionDecoder.Size(); i++)
if(!cActionDecoder[i].WeightsUpdate(GetPointer(Source.cActionDecoder[i]), tau))
ReturnFalse;
//---
return CNeuronConvOCL::WeightsUpdate(source, tau);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHiSSDLowLevelControler::Save(const int file_handle)
{
if(!CNeuronConvOCL::Save(file_handle))
ReturnFalse;
//---
if(FileWriteInteger(file_handle, int(iTaskSkills)) < INT_VALUE)
ReturnFalse;
if(FileWriteInteger(file_handle, int(iCommonSkills)) < INT_VALUE)
ReturnFalse;
//---
if(!cTaskSpecificSkillsEncoder.Save(file_handle))
ReturnFalse;
if(!cTranspose.Save(file_handle))
ReturnFalse;
if(!cNormalizarion.Save(file_handle))
ReturnFalse;
for(uint i = 0; i < cActionDecoder.Size(); i++)
if(!cActionDecoder[i].Save(file_handle))
ReturnFalse;
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CNeuronHiSSDLowLevelControler::Load(const int file_handle)
{
if(!CNeuronConvOCL::Load(file_handle))
ReturnFalse;
//---
if(FileIsEnding(file_handle))
ReturnFalse;
iTaskSkills = (uint)FileReadInteger(file_handle);
if(FileIsEnding(file_handle))
ReturnFalse;
iCommonSkills = (uint)FileReadInteger(file_handle);
//---
if(!LoadInsideLayer(file_handle, cTaskSpecificSkillsEncoder.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cTranspose.AsObject()))
ReturnFalse;
if(!LoadInsideLayer(file_handle, cNormalizarion.AsObject()))
ReturnFalse;
for(uint i = 0; i < cActionDecoder.Size(); i++)
if(!LoadInsideLayer(file_handle, cActionDecoder[i].AsObject()))
ReturnFalse;
//---
if(!cObservAndSkillsConcat.Init(0, 2, OpenCL, cNormalizarion.Neurons(),
optimization, iBatch))
ReturnFalse;
cObservAndSkillsConcat.SetActivationFunction(None);
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CNeuronHiSSDLowLevelControler::SetOpenCL(COpenCLMy * obj)
{
CNeuronConvOCL::SetOpenCL(obj);
//---
cTaskSpecificSkillsEncoder.SetOpenCL(OpenCL);
cTranspose.SetOpenCL(OpenCL);
cObservAndSkillsConcat.SetOpenCL(OpenCL);
cNormalizarion.SetOpenCL(OpenCL);
for(uint i = 0; i < cActionDecoder.Size(); i++)
cActionDecoder[i].SetOpenCL(OpenCL);
}
Reference in a new issue View git blame Copy permalink