//Constructor
/// <summary>
/// Creates an instance ready to build computation cluster
/// </summary>
/// <param name="clusterName">Name of the cluster</param>
/// <param name="networkSettingsCollection">Collection of network configurations (FeedForwardNetworkSettings or ParallelPerceptronSettings objects)</param>
/// <param name="dataRange">Range of input and output data</param>
/// <param name="binBorder">If specified, it indicates that the network ideal output is binary and specifies numeric border where GE network output is decided as a 1 and LT output as a 0.</param>
/// <param name="rand">Random generator to be used (optional)</param>
/// <param name="controller">Regression controller (optional)</param>
public TrainedNetworkClusterBuilder(string clusterName,
List <INonRecurrentNetworkSettings> networkSettingsCollection,
Interval dataRange,
double binBorder = double.NaN,
Random rand = null,
TrainedNetworkBuilder.RegressionControllerDelegate controller = null
)
{
_clusterName = clusterName;
_networkSettingsCollection = networkSettingsCollection;
_dataRange = dataRange;
_binBorder = binBorder;
_rand = rand ?? new Random(0);
_controller = controller;
return;
}
/// <summary>
/// Performs training of the StateMachine
/// </summary>
/// <param name="vectorBundle">Training data bundle (input vectors and desired output vectors)</param>
/// <param name="regressionController">Optional regression controller.</param>
/// <returns>Output of the regression stage</returns>
public TrainingResults Train(VectorBundle vectorBundle, TrainedNetworkBuilder.RegressionControllerDelegate regressionController = null)
{
//StateMachine reset
Reset();
VectorBundle readoutInput;
NeuralPreprocessor.PreprocessingOverview preprocessingOverview = null;
if (NP == null)
{
//Neural preprocessor is bypassed
readoutInput = vectorBundle;
}
else
{
//Neural preprocessing
readoutInput = NP.InitializeAndPreprocessBundle(vectorBundle, out preprocessingOverview);
}
//Training of the readout layer
ReadoutLayer.RegressionOverview regressionOverview = RL.Build(readoutInput, BuildPredictorsMapper(), regressionController);
//Return compact results
return(new TrainingResults(preprocessingOverview, regressionOverview));
}
/// <summary>
/// Builds trained readout layer.
/// </summary>
/// <param name="dataBundle">Collection of input predictors and associated desired output values</param>
/// <param name="predictorsMapper">Optional specific mapping of predictors to readout units</param>
/// <param name="controller">Optional external regression controller</param>
/// <returns>Results of the regression</returns>
public RegressionOverview Build(VectorBundle dataBundle,
PredictorsMapper predictorsMapper = null,
TrainedNetworkBuilder.RegressionControllerDelegate controller = null
)
{
//Basic checks
int numOfPredictors = dataBundle.InputVectorCollection[0].Length;
int numOfOutputs = dataBundle.OutputVectorCollection[0].Length;
if (numOfPredictors == 0)
{
throw new InvalidOperationException($"Number of predictors must be greater tham 0.");
}
if (numOfOutputs != Settings.ReadoutUnitsCfg.ReadoutUnitCfgCollection.Count)
{
throw new InvalidOperationException($"Incorrect length of output vectors.");
}
//Predictors mapper (specified or default)
_predictorsMapper = predictorsMapper ?? new PredictorsMapper(numOfPredictors);
//Allocation and preparation of feature filters
//Predictors
_predictorFeatureFilterCollection = new FeatureFilterBase[numOfPredictors];
Parallel.For(0, _predictorFeatureFilterCollection.Length, nrmIdx =>
{
_predictorFeatureFilterCollection[nrmIdx] = new RealFeatureFilter(DataRange, true, true);
for (int pairIdx = 0; pairIdx < dataBundle.InputVectorCollection.Count; pairIdx++)
{
//Adjust filter
_predictorFeatureFilterCollection[nrmIdx].Update(dataBundle.InputVectorCollection[pairIdx][nrmIdx]);
}
});
//Output values
_outputFeatureFilterCollection = new FeatureFilterBase[numOfOutputs];
Parallel.For(0, _outputFeatureFilterCollection.Length, nrmIdx =>
{
_outputFeatureFilterCollection[nrmIdx] = FeatureFilterFactory.Create(DataRange, Settings.ReadoutUnitsCfg.ReadoutUnitCfgCollection[nrmIdx].TaskCfg.FeatureFilterCfg);
for (int pairIdx = 0; pairIdx < dataBundle.OutputVectorCollection.Count; pairIdx++)
{
//Adjust output normalizer
_outputFeatureFilterCollection[nrmIdx].Update(dataBundle.OutputVectorCollection[pairIdx][nrmIdx]);
}
});
//Data normalization
//Allocation
double[][] normalizedPredictorsCollection = new double[dataBundle.InputVectorCollection.Count][];
double[][] normalizedIdealOutputsCollection = new double[dataBundle.OutputVectorCollection.Count][];
//Normalization
Parallel.For(0, dataBundle.InputVectorCollection.Count, pairIdx =>
{
//Predictors
double[] predictors = new double[numOfPredictors];
for (int i = 0; i < numOfPredictors; i++)
{
if (_predictorsMapper.PredictorGeneralSwitchCollection[i])
{
predictors[i] = _predictorFeatureFilterCollection[i].ApplyFilter(dataBundle.InputVectorCollection[pairIdx][i]);
}
else
{
predictors[i] = double.NaN;
}
}
normalizedPredictorsCollection[pairIdx] = predictors;
//Outputs
double[] outputs = new double[numOfOutputs];
for (int i = 0; i < numOfOutputs; i++)
{
outputs[i] = _outputFeatureFilterCollection[i].ApplyFilter(dataBundle.OutputVectorCollection[pairIdx][i]);
}
normalizedIdealOutputsCollection[pairIdx] = outputs;
});
//Random object initialization
Random rand = new Random(0);
//Create shuffled copy of the data
VectorBundle shuffledData = new VectorBundle(normalizedPredictorsCollection, normalizedIdealOutputsCollection);
shuffledData.Shuffle(rand);
//Building of readout units
for (int unitIdx = 0; unitIdx < Settings.ReadoutUnitsCfg.ReadoutUnitCfgCollection.Count; unitIdx++)
{
List <double[]> idealValueCollection = new List <double[]>(shuffledData.OutputVectorCollection.Count);
//Transformation of ideal vectors to a single value vectors
foreach (double[] idealVector in shuffledData.OutputVectorCollection)
{
double[] value = new double[1];
value[0] = idealVector[unitIdx];
idealValueCollection.Add(value);
}
List <double[]> readoutUnitInputVectorCollection = _predictorsMapper.CreateVectorCollection(Settings.ReadoutUnitsCfg.ReadoutUnitCfgCollection[unitIdx].Name, shuffledData.InputVectorCollection);
VectorBundle readoutUnitDataBundle = new VectorBundle(readoutUnitInputVectorCollection, idealValueCollection);
TrainedNetworkClusterBuilder readoutUnitBuilder = new TrainedNetworkClusterBuilder(Settings.ReadoutUnitsCfg.ReadoutUnitCfgCollection[unitIdx].Name,
Settings.GetReadoutUnitNetworksCollection(unitIdx),
DataRange,
Settings.ReadoutUnitsCfg.ReadoutUnitCfgCollection[unitIdx].TaskCfg.Type == ReadoutUnit.TaskType.Classification ? BinBorder : double.NaN,
rand,
controller
);
//Register notification
readoutUnitBuilder.RegressionEpochDone += OnRegressionEpochDone;
//Build trained readout unit. Trained unit becomes to be the predicting cluster member
_readoutUnitCollection[unitIdx] = new ReadoutUnit(unitIdx,
readoutUnitBuilder.Build(readoutUnitDataBundle,
Settings.TestDataRatio,
Settings.Folds,
Settings.Repetitions,
new FeatureFilterBase[] { _outputFeatureFilterCollection[unitIdx] }
)
);
}//unitIdx
//Readout layer is trained and ready
Trained = true;
return(new RegressionOverview(ReadoutUnitErrStatCollection));
}
