/// <inheritdoc/>
public double Compute(BasicStat continuousActivationStat,
BasicStat continuousActivationDiffStat,
MovingDataWindow activationMDW,
SimpleQueue <byte> firingMDW,
double activation,
double normalizedActivation,
bool spike
)
{
PredictorActivationDiffStatFigureSettings cfg = (PredictorActivationDiffStatFigureSettings)Cfg;
if (cfg.Window == PredictorActivationDiffStatFigureSettings.NAWindowNum)
{
return(continuousActivationDiffStat.Get(cfg.Figure));
}
else
{
if (activationMDW.UsedCapacity >= cfg.Window)
{
return(activationMDW.GetDataDiffStat(cfg.Window).Get(cfg.Figure));
}
else
{
return(0d);
}
}
}
/// <inheritdoc/>
public double Compute(BasicStat continuousActivationStat,
BasicStat continuousActivationDiffStat,
MovingDataWindow activationMDW,
SimpleQueue <byte> firingMDW,
double activation,
double normalizedActivation,
bool spike
)
{
PredictorFiringTraceSettings cfg = (PredictorFiringTraceSettings)Cfg;
if (cfg.Window == PredictorFiringTraceSettings.NAWindowNum)
{
return(_continuousTrace);
}
else
{
if (firingMDW.Count >= cfg.Window)
{
double trace = 0d;
for (int i = cfg.Window - 1; i >= 0; i--)
{
trace *= (1d - cfg.Fading);
trace += firingMDW.GetElementAt(i, true);
}
return(trace);
}
else
{
return(0d);
}
}
}
/// <inheritdoc/>
public double Compute(BasicStat continuousActivationStat,
BasicStat continuousActivationDiffStat,
MovingDataWindow activationMDW,
SimpleQueue <byte> firingMDW,
double activation,
double normalizedActivation,
bool spike
)
{
return(activation);
}
/// <inheritdoc/>
public double Compute(BasicStat continuousActivationStat,
BasicStat continuousActivationDiffStat,
MovingDataWindow activationMDW,
SimpleQueue <byte> firingMDW,
double activation,
double normalizedActivation,
bool spike
)
{
PredictorActivationPowerSettings cfg = (PredictorActivationPowerSettings)Cfg;
return(Math.Pow(Math.Abs(activation), cfg.Exponent) * (cfg.KeepSign ? Math.Sign(activation) : 1d));
}
/// <inheritdoc/>
public double Compute(BasicStat continuousActivationStat,
BasicStat continuousActivationDiffStat,
MovingDataWindow activationMDW,
SimpleQueue <byte> firingMDW,
double activation,
double normalizedActivation,
bool spike
)
{
PredictorActivationDiffRescaledRangeSettings cfg = (PredictorActivationDiffRescaledRangeSettings)Cfg;
if (activationMDW.UsedCapacity >= cfg.Window)
{
return(activationMDW.GetDataDiffRescaledRange(cfg.Window));
}
else
{
return(0d);
}
}
/// <summary>
/// Creates new initialized instance.
/// </summary>
/// <param name="cfg">The configuration.</param>
public PredictorsProvider(PredictorsProviderSettings cfg)
{
int reqAMDWCapacity = 0;
int reqFMDWCapacity = 0;
_predictorCollection = new List <IPredictor>(cfg.NumOfPredictors);
_activationMDW = null;
_firingMDW = null;
_activationStat = null;
_activationDiffStat = null;
foreach (IPredictorSettings predictorCfg in cfg.PredictorCfgCollection)
{
IPredictor predictor = PredictorFactory.CreatePredictor(predictorCfg);
reqAMDWCapacity = Math.Max(reqAMDWCapacity, predictor.Cfg.RequiredWndSizeOfActivations);
reqFMDWCapacity = Math.Max(reqFMDWCapacity, predictor.Cfg.RequiredWndSizeOfFirings);
if (predictor.Cfg.NeedsContinuousActivationStat && _activationStat == null)
{
_activationStat = new BasicStat();
}
if (predictor.Cfg.NeedsContinuousActivationDiffStat && _activationDiffStat == null)
{
_activationDiffStat = new BasicStat();
}
_predictorCollection.Add(predictor);
}
if (reqAMDWCapacity > 0)
{
_activationMDW = new MovingDataWindow(reqAMDWCapacity);
}
if (reqFMDWCapacity > 0)
{
_firingMDW = new SimpleQueue <byte>(reqFMDWCapacity);
}
Reset();
return;
}
/// <summary>
/// Creates new initialized instance.
/// </summary>
/// <param name="cfg">Configuration to be used. Note that ParamsCfg member inside the cfg must not be null.</param>
public PredictorsProvider(PredictorsSettings cfg)
{
//Check
if (cfg.ParamsCfg == null)
{
throw new ArgumentException("Invalid configuration. ParamsCfg inside the configuration is null.", "cfg");
}
//Store configuration
_cfg = cfg;
//Determine necessary size of the activation moving window and instantiate it
int activationMWSize = 0;
if (_cfg.IsEnabled(PredictorID.ActivationMWAvg))
{
switch (_cfg.ParamsCfg.ActivationMWAvgCfg.Weights)
{
case PredictorMWAvgWeightsType.Exponential:
_activationMWAvgWeights = _expWeightsCache;
activationMWSize = Math.Min(_cfg.ParamsCfg.ActivationMWAvgCfg.Window, _expWeightsCache.Length);
break;
case PredictorMWAvgWeightsType.Linear:
_activationMWAvgWeights = _linWeightsCache;
activationMWSize = Math.Min(_cfg.ParamsCfg.ActivationMWAvgCfg.Window, _linWeightsCache.Length);
break;
case PredictorMWAvgWeightsType.Constant:
_activationMWAvgWeights = null;
activationMWSize = _cfg.ParamsCfg.ActivationMWAvgCfg.Window;
break;
default:
throw new InvalidOperationException($"Unsupported weights type {_cfg.ParamsCfg.ActivationMWAvgCfg.Weights}.");
}
}
_activationMDW = activationMWSize == 0 ? null : new MovingDataWindow(activationMWSize);
//Determine necessary size of the firing moving window and instantiate it
int firingMWSize = 0;
if (_cfg.IsEnabled(PredictorID.FiringMWAvg))
{
switch (_cfg.ParamsCfg.FiringMWAvgCfg.Weights)
{
case PredictorMWAvgWeightsType.Exponential:
_firingMWAvgWeights = _expWeightsCache;
firingMWSize = Math.Min(_cfg.ParamsCfg.FiringMWAvgCfg.Window, _expWeightsCache.Length);
break;
case PredictorMWAvgWeightsType.Linear:
_firingMWAvgWeights = _linWeightsCache;
firingMWSize = Math.Min(_cfg.ParamsCfg.FiringMWAvgCfg.Window, _linWeightsCache.Length);
break;
case PredictorMWAvgWeightsType.Constant:
_firingMWAvgWeights = null;
firingMWSize = _cfg.ParamsCfg.FiringMWAvgCfg.Window;
break;
default:
throw new InvalidOperationException($"Unsupported weights type {_cfg.ParamsCfg.FiringMWAvgCfg.Weights}.");
}
}
if (_cfg.IsEnabled(PredictorID.FiringBinPattern))
{
firingMWSize = Math.Max(firingMWSize, _cfg.ParamsCfg.FiringBinPatternCfg.Window);
}
if (_cfg.IsEnabled(PredictorID.FiringCount))
{
firingMWSize = Math.Max(firingMWSize, _cfg.ParamsCfg.FiringCountCfg.Window);
}
_firingMDW = firingMWSize == 0 ? null : new Bitwise.Window(firingMWSize);
Reset();
return;
}
