/// <summary>
/// Runs through the network and makes a prediction.
/// </summary>
/// <param name="input">The input image to run the prediction on.</param>
/// <returns>The values from the final layer. The largest value is the networks prediction.</returns>
public double[] FeedForward(double[] input)
{
Matrix <double> _currentImages = CreateMatrix.DenseOfRowVectors(CreateVector.DenseOfArray <double>(input));
foreach (ILayerInformation _layerInformation in this.LayerInformation)
{
switch (_layerInformation.LayerType)
{
case (LayerType.Convolutional):
ConvolutionalLayerInformation _convInfo = _layerInformation as ConvolutionalLayerInformation;
_currentImages = this.Convolve(_convInfo, _currentImages);
break;
case (LayerType.Pooling):
PoolingLayerInformation _poolInfo = _layerInformation as PoolingLayerInformation;
_currentImages = this.Pool(_poolInfo, _currentImages);
break;
case (LayerType.NonLinear):
NonLinearLayerInformation _nonLinearInfo = _layerInformation as NonLinearLayerInformation;
_currentImages = this.NonLinear(_nonLinearInfo, _currentImages);
break;
}
}
double[] _fullyConnectedInput = CreateVector.DenseOfEnumerable <double>(_currentImages.EnumerateRows().SelectMany(a => a)).ToArray();
return(this.FullyConnectedNetwork.FeedForward(_currentImages.Enumerate().ToArray()));
}
private List <Vector <double> > Normalize(List <Vector <double> > values)
{
var columns = CreateMatrix.DenseOfRowVectors(values).EnumerateColumns();
var mean = CreateVector.DenseOfEnumerable(columns.Select(Statistics.Mean));
var std = CreateVector.DenseOfEnumerable(columns.Select(Statistics.StandardDeviation));
return(values.Select(v => (v - mean) / std).ToList());
}
public List <double> GetEnergy(Vector <double> pattern)
{
Vector <double> S = pattern, previous = null;
List <double> energy = new List <double>();
while (!S.Equals(previous) && !patterns.Contains(S))
{
energy.Add(-0.5 * (W * S * S));
previous = S;
S = CreateVector.DenseOfEnumerable((W * S).Select((v, index) => v != 0 ? Math.Sign(v) : S[index]));
}
return(energy);
}
public List <Vector <double> > GetPattern(Vector <double> pattern)
{
Vector <double> S = pattern, previous = null;
List <Vector <double> > patterns = new List <Vector <double> >();
while (!S.Equals(previous) && !patterns.Contains(S))
{
patterns.Add(S);
previous = S;
S = CreateVector.DenseOfEnumerable((W * S).Select((v, index) => v != 0 ? Math.Sign(v) : S[index]));
}
return(patterns);
}
public OjaNetwork(double learningRate, int epochs, List <Vector <double> > values)
{
this.epochs = epochs;
var columns = CreateMatrix.DenseOfRowVectors(values).EnumerateColumns();
var mean = CreateVector.DenseOfEnumerable(columns.Select(Statistics.Mean));
var std = CreateVector.DenseOfEnumerable(columns.Select(Statistics.StandardDeviation));
this.values = values.Select(v => (v - mean) / std).ToList();
this.variables = values[1].Count;
this.W = CreateVector.Random <double>(variables, new ContinuousUniform(-1, 1));
this.LearningRate = learningRate;
}
public Vector <double> Resolve(Parameter parameter) => CreateVector.DenseOfEnumerable(vector.Select(x => x.Resolve(parameter)));
private void AnalyzeButton_Click(object sender, EventArgs e)
{
int numSkipped = 0;
int numValid = 0;
List <ETan> ETans = new List <ETan>();
List <double> measuredVals = new List <double>();
List <double> predictedVals = new List <double>();
foreach (ETan etanRow in ETanFilesListBox.Items)
{
foreach (MeasSummary.SummaryRow sumrow in etanRow.summrow)
{
if (etanRow.summrow == null ||
(VoltageMode && Double.IsNaN(sumrow.PeakHeaderVoltage)) ||
(!VoltageMode && Double.IsNaN(sumrow.MeasuredTemperature))
)
{
numSkipped++;
continue;
}
var scaledEtanRms = etanRow.rms.Multiply(sumrow.ETanScalingFactor);
if (sumrow.Conjugate)
{
scaledEtanRms = scaledEtanRms.Conjugate();
}
if (VoltageMode && !Double.IsNaN(sumrow.CrestFactor))
{
scaledEtanRms = scaledEtanRms.Multiply(sumrow.CrestFactor);
}
double Z = DataProcessing.TFInt(
ETan_Z: etanRow.z, ETan_RMS: scaledEtanRms,
TF_Z: TFz, TF_Sr: TFSr);
if (VoltageMode)
{
Z = Math.Sqrt(Z);
}
ETans.Add(etanRow);
double measuredVal;
if (VoltageMode)
{
measuredVal = sumrow.PeakHeaderVoltage;
}
else
{
measuredVal = sumrow.MeasuredTemperature;
}
measuredVals.Add(measuredVal);
predictedVals.Add(Z);
numValid++;
}
}
if (numValid == 0)
{
MessageBox.Show(this, "No valid data was found.",
"No Data",
MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (numSkipped > 0)
{
MessageBox.Show(this, numSkipped.ToString() + " Etan files were skipped " +
"because a cooresponding row in the measurement summary file was not found.",
"Skipped ETan Files", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
double scaleFactor;
// TODO: Are these two things reversed? I need another person to double-check.
//var A = CreateMatrix.DenseOfColumns(new IEnumerable<double>[] { measuredVals });
//var B = CreateVector.DenseOfEnumerable(predictedVals);
var A = CreateMatrix.DenseOfColumns(new IEnumerable <double>[] { predictedVals });
var B = CreateVector.DenseOfEnumerable(measuredVals);
var X = A.QR().Solve(B); // A*X = B
scaleFactor = 1.0 / X[0];
double TFScaleFactor = VoltageMode ? scaleFactor : Math.Sqrt(scaleFactor); // Scalefactor used for scaling the TF
// Save things
SaveScaledTF(TFScaleFactor);
if (saveSummaryFileCheckbox.Checked)
{
SaveSummaryTable(ETans, predictedVals, scaleFactor);
}
TFFitPlotForm tffpf = new TFFitPlotForm();
tffpf.AddData(
predicted: predictedVals,
measured: measuredVals,
varName: VoltageMode ? "V" : "dT",
title: TransferFunctionFilenameLabel.Text
);
tffpf.AddFit(1.0 / scaleFactor, 0, Color.Red);
tffpf.Show(this);
}
