//Constructor
/// <summary>
/// Creates an initialized instance.
/// </summary>
/// <param name="cfg">The configuration of the predictor.</param>
public PredictorActivationLinWAvg(PredictorActivationLinWAvgSettings cfg)
{
Cfg = cfg;
if (cfg.Window == PredictorActivationLinWAvgSettings.NAWindowNum)
{
_continuousAvg = new WeightedAvg();
Reset();
}
else
{
_continuousAvg = null;
}
return;
}
/// <summary>
/// Computes the composite output of the cluster.
/// </summary>
private double[] ComputeCompositeOutput(List <Tuple <int, double[]> > memberNetOutputs)
{
if (Output == TNRNet.OutputType.Real)
{
//Real output
double[] output = new double[NumOfOutputs];
for (int outIdx = 0; outIdx < NumOfOutputs; outIdx++)
{
//Compute weighted average of members single output
WeightedAvg wAvg = new WeightedAvg();
for (int i = 0; i < memberNetOutputs.Count; i++)
{
//Add sub-result to weighted average
wAvg.AddSample(memberNetOutputs[i].Item2[outIdx], _memberNetWeights[i]);
}
//Store averaged output
output[outIdx] = wAvg.Result;
}
//Return averaged outputs
return(output);
}
else
{
//Probabilistic or SingleBool output
int numOfOutputProbabilities = memberNetOutputs[0].Item2.Length;
double[] outProbabilities = new double[numOfOutputProbabilities];
for (int pIdx = 0; pIdx < numOfOutputProbabilities; pIdx++)
{
double[] memberPs = new double[NumOfMembers];
for (int i = 0; i < NumOfMembers; i++)
{
memberPs[i] = PMixer.ProbabilityRange.Rescale(memberNetOutputs[i].Item2[pIdx], OutputDataRange);
}
//Compute members mixed probability
outProbabilities[pIdx] = PMixer.MixP(memberPs, _memberNetWeights);
}
if (numOfOutputProbabilities > 1)
{
outProbabilities.ScaleToNewSum(1d);
}
//Rescale probabilities to output range
for (int pIdx = 0; pIdx < numOfOutputProbabilities; pIdx++)
{
outProbabilities[pIdx] = OutputDataRange.Rescale(outProbabilities[pIdx], PMixer.ProbabilityRange);
}
return(outProbabilities);
}
}
//Methods
private double Compute(double[] predictors, int clusterIdx)
{
WeightedAvg wAvg = new WeightedAvg();
for (int readoutUnitIdx = 0; readoutUnitIdx < _clusterCollection[clusterIdx].Length; readoutUnitIdx++)
{
double[] outputValue = _clusterCollection[clusterIdx][readoutUnitIdx].Network.Compute(predictors);
double weight = _clusterCollection[clusterIdx][readoutUnitIdx].TrainingErrorStat.NumOfSamples;
if (_clusterCollection[clusterIdx][readoutUnitIdx].TestingErrorStat != null)
{
weight += _clusterCollection[clusterIdx][readoutUnitIdx].TestingErrorStat.NumOfSamples;
}
wAvg.AddSampleValue(outputValue[0], weight);
// Or flat weight
//wAvg.AddSampleValue(outputValue[0], 1);
}
return(wAvg.Avg);
}
//Methods
/// <summary>
/// Computes weighted averaged output of the cluster member networks
/// </summary>
/// <param name="predictors">Input predictors</param>
/// <param name="memberOutputCollection">Collection of outputs of cluster member networks</param>
public double Compute(double[] predictors, out double[] memberOutputCollection)
{
//Init member output collection
memberOutputCollection = new double[Members.Count];
if (!BinaryOutput)
{
//Result is exact value
WeightedAvg weightedResult = new WeightedAvg();
//Loop cluster members
int clusterMemberIdx = 0;
foreach (TrainedNetwork clusterMember in Members)
{
//Compute member
double computedValue = clusterMember.Network.Compute(predictors)[0];
//Store sub-results
memberOutputCollection[clusterMemberIdx] = computedValue;
//Add sub-result to weighted average
weightedResult.AddSampleValue(computedValue, Weights[clusterMemberIdx]);
++clusterMemberIdx;
}
//Return weighted average result
return(weightedResult.Avg);
}
else
{
//Result is a probability -> use probability mixer
double[] probabilities = new double[Members.Count];
double[] weights = new double[Members.Count];
for (int i = 0; i < Members.Count; i++)
{
memberOutputCollection[i] = Members[i].Network.Compute(predictors)[0];
probabilities[i] = PMixer.ProbabilityRange.Rescale(memberOutputCollection[i], DataRange);
weights[i] = Weights[i];
}
//Scale weights to ensure their sum is equal to 1
weights.Scale(1d / weights.Sum());
//Return resulting mixed probability rescalled back to members' result range
return(DataRange.Rescale(PMixer.MixP(probabilities, weights), PMixer.ProbabilityRange));
}
}
/// <summary>
/// Merge the partially computed aggregate with this aggregate
/// </summary>
/// <param name="Group">The other partial results to be merged</param>
public void Merge(WeightedAvg Group)
{
this.sum += Group.sum;
this.count += Group.count;
}
