private double AnswerTestSet()
{
foreach (Pattern p in testSet.EnumeratePatterns())
{
p.NetworkAnswer = network.ComputeOutput(p.Input);
}
double mseSum = 0.0;
foreach (Pattern p in testSet.EnumeratePatterns())
{
double vectorMSE = 0.0;
for (int i = 0; i < testSet.Extremums.OutputExtremums.Count; i++)
{
DataExtremum extr = testSet.Extremums.OutputExtremums[i];
double denormAns = extr.Normalizor.NormalizeBack(p.NetworkAnswer[i]);
double denormIdeal = extr.Normalizor.NormalizeBack(p.IdealOutput[i]);
vectorMSE += (denormAns - denormIdeal) * (denormAns - denormIdeal);
}
mseSum += vectorMSE / testSet.Extremums.OutputExtremums.Count;
}
// double min;
// double max;
// Normalizor.GetMinMaxActivationWithMargin(network.Activation.MinValue, network.Activation.MaxValue, out min, out max);
return(MSECalculator.CalculateEpochMSEDenormalized(mseSum, testSet.PatternCount));
}
public PlotModel Build1DRegressionModel(IDataSet trainingSet, IDataSet testSet, bool plotAgainstInput) // if plotAgainstInput is true, use input as X axis, not time
{
List <RegressionPoint> trainPoints = new List <RegressionPoint>();
List <RegressionPoint> testIdealPoints = new List <RegressionPoint>();
List <RegressionPoint> networkAnswers = new List <RegressionPoint>();
Func <Pattern, double> patternToDouble;
if (plotAgainstInput)
{
patternToDouble = p => p.Input[0];
}
else
{
patternToDouble = p => p.TimeIndex;
}
foreach (Pattern p in trainingSet.EnumeratePatterns())
{
trainPoints.Add(new RegressionPoint(patternToDouble(p), p.IdealOutput.At(0)));
}
foreach (Pattern p in testSet.EnumeratePatterns())
{
testIdealPoints.Add(new RegressionPoint(patternToDouble(p), p.IdealOutput.At(0)));
networkAnswers.Add(new RegressionPoint(patternToDouble(p), p.NetworkAnswer.At(0)));
}
PlotModel regressionPlotModel = SetUpModel(trainPoints, testIdealPoints, networkAnswers);
return(regressionPlotModel);
}
protected virtual double CalculateMSEError(INetwork network, IDataSet dataSet)
{
double mseSum = 0.0;
foreach (Pattern p in dataSet.EnumeratePatterns())
{
mseSum += MSECalculator.CalculateRawMSE(p.IdealOutput - network.ComputeOutput(p.Input));
}
double min;
double max;
Normalizor.GetMinMaxActivationWithMargin(network.Activation.MinValue, network.Activation.MaxValue, out min, out max);
return(MSECalculator.CalculateEpochMSE(mseSum, dataSet.PatternCount, min, max));
}
public static void Run(IDataSet set, int destinationInputLenght, double minTo, double maxTo)
{
// Preprocessing
if (set == null ||
set.EnumeratePatterns().First() == null ||
set.EnumeratePatterns().First().Input == null)
{
throw new ArgumentException();
}
int inputLenght = set.EnumeratePatterns().First().Input.Count;
if (destinationInputLenght >= inputLenght)
{
return;
}
// Calculating matrix R
Matrix <double> R = new DenseMatrix(inputLenght, inputLenght);
foreach (var pattern in set.EnumeratePatterns())
{
R += pattern.Input.OuterProduct(pattern.Input);
}
R /= set.PatternCount;
// QR decomposition
var qr = R.QR(QRMethod.Full);
// Calculating eigenvectors and eigenvalues
var eigens = new List <Eigen>();
var diagonal = qr.Q.Inverse() * R * qr.Q;
for (int i = 0; i < inputLenght; i++)
{
eigens.Add(new Eigen
{
Vector = qr.Q.Column(i),
Value = diagonal[i, i],
});
}
//TestEigenValues(eigens, R, inputLenght);
// Selecting eigenvectors with the biggest eigenvalues
var pcaColumns = eigens
.OrderByDescending(x => x.Value)
.Take(destinationInputLenght)
.Select(x => x.Vector)
.ToList();
// Creating transform matrix
Matrix <double> pcaTransform = new DenseMatrix(inputLenght, destinationInputLenght);
for (int i = 0; i < destinationInputLenght; i++)
{
pcaTransform.SetColumn(i, pcaColumns[i]);
}
// Transforming input vectors
double maxFrom = Double.MinValue;
double minFrom = Double.MaxValue;
foreach (var pattern in set.EnumeratePatterns())
{
pattern.Input = pattern.Input * pcaTransform;
maxFrom = Math.Max(maxFrom, pattern.Input.Maximum());
minFrom = Math.Min(minFrom, pattern.Input.Minimum());
}
// Normalization
var norm = new Normalizor(minFrom, maxFrom, minTo, maxTo);
foreach (var pattern in set.EnumeratePatterns())
{
pattern.Input.MapInplace(norm.Normalize);
}
}
