/// <summary>
/// Processes a double array of data of input and a second array of data for ideals
/// you must input the input and output size.
/// this typically builds a supervised IMLDatapair, which you must add to a IMLDataset.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="ideal">The ideal.</param>
/// <param name="_inputWindow">The _input window.</param>
/// <param name="_predictWindow">The _predict window.</param>
/// <returns></returns>
public static IMLDataPair ProcessPairs(double[] data, double[] ideal, int _inputWindow, int _predictWindow)
{
var result = new BasicMLDataSet();
for (int i = 0; i < data.Length; i++)
{
var inputData = new BasicMLData(_inputWindow);
var idealData = new BasicMLData(_predictWindow);
int index = i;
// handle input window
for (int j = 0; j < _inputWindow; j++)
{
inputData[j] = data[index++];
}
index = 0;
// handle predict window
for (int j = 0; j < _predictWindow; j++)
{
idealData[j] = ideal[index++];
}
IMLDataPair pair = new BasicMLDataPair(inputData, idealData);
return(pair);
}
return(null);
}
/// <summary>
/// Process the array.
/// </summary>
///
/// <param name="data">The array to process.</param>
/// <returns>A neural data set that contains the time-series.</returns>
public IMLDataSet Process(double[] data)
{
var result = new BasicMLDataSet();
int totalWindowSize = _inputWindow + _predictWindow;
int stopPoint = data.Length - totalWindowSize;
for (int i = 0; i < stopPoint; i++)
{
var inputData = new BasicMLData(_inputWindow);
var idealData = new BasicMLData(_predictWindow);
int index = i;
// handle input window
for (int j = 0; j < _inputWindow; j++)
{
inputData[j] = data[index++];
}
// handle predict window
for (int j = 0; j < _predictWindow; j++)
{
idealData[j] = data[index++];
}
var pair = new BasicMLDataPair(inputData, idealData);
result.Add(pair);
}
return(result);
}
public void GetResults()
{
foreach (Texture2D texture in OpenFile.Open())
{
IMLDataPair pair = new BasicMLDataPair(new BasicMLData(Texture2List(texture).ToArray()));
IMLData output = basicNetwork.Compute(pair.Input);
string result = "";
float ideal = 0;
if (output[0] < 0.25f)
{
result = "Normal";
}
else if (output[0] > 0.25f && output[0] < 0.75f)
{
result = "Esquemico";
ideal = 0.5f;
}
else
{
result = "Hemorragico";
ideal = 1.0f;
}
Debug.Log("Isso parece ser: " + result + "\nEquivalência{ Imagem Testada: " + output[0] + " Imagem Original: " + ideal + " }");
debugText.text = ("Isso parece ser: " + result + "\nEquivalência{ Imagem Testada: " + output[0] + " Imagem Original: " + ideal + " }");
}
}
/// <summary>
/// Load a CSV file into a memory dataset.
/// </summary>
///
/// <param name="format">The CSV format to use.</param>
/// <param name="filename">The filename to load.</param>
/// <param name="headers">True if there is a header line.</param>
/// <param name="inputSize">The input size. Input always comes first in a file.</param>
/// <param name="idealSize">The ideal size, 0 for unsupervised.</param>
/// <returns>A NeuralDataSet that holds the contents of the CSV file.</returns>
public static IMLDataSet LoadCSVTOMemory(CSVFormat format, String filename,
bool headers, int inputSize, int idealSize)
{
var result = new BasicMLDataSet();
var csv = new ReadCSV(filename, headers, format);
while (csv.Next())
{
BasicMLData ideal = null;
int index = 0;
var input = new BasicMLData(inputSize);
for (int i = 0; i < inputSize; i++)
{
double d = csv.GetDouble(index++);
input[i] = d;
}
if (idealSize > 0)
{
ideal = new BasicMLData(idealSize);
for (int i = 0; i < idealSize; i++)
{
double d = csv.GetDouble(index++);
ideal[i] = d;
}
}
IMLDataPair pair = new BasicMLDataPair(input, ideal);
result.Add(pair);
}
return(result);
}
/// <summary>
/// Process the data array and returns an IMLdatapair.
/// </summary>
///
/// <param name="data">The array to process.</param>
/// <returns>An IMLDatapair containing data.</returns>
public IMLDataPair ProcessToPair(double[] data)
{
// not sure this method works right: it's only using the last pair?
IMLDataPair pair = null;
int totalWindowSize = _inputWindow + _predictWindow;
int stopPoint = data.Length - totalWindowSize;
for (int i = 0; i < stopPoint; i++)
{
var inputData = new BasicMLData(_inputWindow);
var idealData = new BasicMLData(_predictWindow);
int index = i;
// handle input window
for (int j = 0; j < _inputWindow; j++)
{
inputData[j] = data[index++];
}
// handle predict window
for (int j = 0; j < _predictWindow; j++)
{
idealData[j] = data[index++];
}
pair = new BasicMLDataPair(inputData, idealData);
}
return(pair);
}
/// <summary>
/// Evaluate memory.
/// </summary>
private void EvalMemory()
{
BasicMLDataSet training = RandomTrainingFactory.Generate(
1000, 10000, 10, 10, -1, 1);
const long stop = (10 * Evaluate.Milis);
int record = 0;
IMLDataPair pair = BasicMLDataPair.CreatePair(10, 10);
int iterations = 0;
var watch = new Stopwatch();
watch.Start();
while (watch.ElapsedMilliseconds < stop)
{
iterations++;
training.GetRecord(record++, pair);
if (record >= training.Count)
{
record = 0;
}
}
iterations /= 100000;
_report.Report(Steps, Step2,
"Memory dataset, result: " + Format.FormatInteger(iterations));
_memoryScore = iterations;
}
/// <summary>
/// Process the data array and returns an IMLdatapair.
/// </summary>
///
/// <param name="data">The array to process.</param>
/// <returns>An IMLDatapair containing data.</returns>
public IMLDataPair ProcessToPair(double[] data)
{
IMLDataPair pair = null;
int totalWindowSize = _inputWindow + _predictWindow;
int stopPoint = data.Length - totalWindowSize;
for (int i = 0; i < stopPoint; i++)
{
IMLData inputData = new BasicMLData(_inputWindow);
IMLData idealData = new BasicMLData(_predictWindow);
int index = i;
// handle input window
for (int j = 0; j < _inputWindow; j++)
{
inputData[j] = data[index++];
}
// handle predict window
for (int j = 0; j < _predictWindow; j++)
{
idealData[j] = data[index++];
}
pair = new BasicMLDataPair(inputData, idealData);
}
return(pair);
}
/// <summary>
/// Processes the specified double serie into an IMLDataset.
/// To use this method, you must provide a formated double array.
/// The number of points in the input window makes the input array , and the predict window will create the array used in ideal.
/// Example you have an array with 1, 2, 3 , 4 , 5.
/// You can use this method to make an IMLDataset 4 inputs and 1 ideal (5).
/// </summary>
/// <param name="data">The data.</param>
/// <param name="_inputWindow">The _input window.</param>
/// <param name="_predictWindow">The _predict window.</param>
/// <returns></returns>
public static IMLDataSet ProcessDoubleSerieIntoIMLDataset(double[] data, int _inputWindow, int _predictWindow)
{
IMLDataSet result = new BasicMLDataSet();
int totalWindowSize = _inputWindow + _predictWindow;
int stopPoint = data.Length - totalWindowSize;
for (int i = 0; i < stopPoint; i++)
{
IMLData inputData = new BasicMLData(_inputWindow);
IMLData idealData = new BasicMLData(_predictWindow);
int index = i;
// handle input window
for (int j = 0; j < _inputWindow; j++)
{
inputData[j] = data[index++];
}
// handle predict window
for (int j = 0; j < _predictWindow; j++)
{
idealData[j] = data[index++];
}
IMLDataPair pair = new BasicMLDataPair(inputData, idealData);
result.Add(pair);
}
return(result);
}
/// <summary>
/// Construct a gradient worker.
/// </summary>
///
/// <param name="theNetwork">The network to train.</param>
/// <param name="theOwner">The owner that is doing the training.</param>
/// <param name="theTraining">The training data.</param>
/// <param name="theLow">The low index to use in the training data.</param>
/// <param name="theHigh">The high index to use in the training data.</param>
/// <param name="theFlatSpots">Holds an array of flat spot constants.</param>
public GradientWorker(FlatNetwork theNetwork,
Propagation theOwner, IMLDataSet theTraining,
int theLow, int theHigh, double[] theFlatSpots, IErrorFunction ef)
{
_errorCalculation = new ErrorCalculation();
_network = theNetwork;
_training = theTraining;
_low = theLow;
_high = theHigh;
_owner = theOwner;
_flatSpot = theFlatSpots;
_layerDelta = new double[_network.LayerOutput.Length];
_gradients = new double[_network.Weights.Length];
_actual = new double[_network.OutputCount];
_weights = _network.Weights;
_layerIndex = _network.LayerIndex;
_layerCounts = _network.LayerCounts;
_weightIndex = _network.WeightIndex;
_layerOutput = _network.LayerOutput;
_layerSums = _network.LayerSums;
_layerFeedCounts = _network.LayerFeedCounts;
_ef = ef;
_pair = BasicMLDataPair.CreatePair(_network.InputCount,
_network.OutputCount);
}
/// <summary>
/// Generate a random training set.
/// </summary>
/// <param name="seed">The seed value to use, the same seed value will always produce
/// the same results.</param>
/// <param name="count">How many training items to generate.</param>
/// <param name="inputCount">How many input numbers.</param>
/// <param name="idealCount">How many ideal numbers.</param>
/// <param name="min">The minimum random number.</param>
/// <param name="max">The maximum random number.</param>
/// <returns>The random training set.</returns>
public static BasicMLDataSet Generate(long seed,
int count, int inputCount,
int idealCount, double min, double max)
{
var rand =
new LinearCongruentialGenerator(seed);
var result = new BasicMLDataSet();
for (int i = 0; i < count; i++)
{
var inputData = new BasicMLData(inputCount);
for (int j = 0; j < inputCount; j++)
{
inputData[j] = rand.Range(min, max);
}
var idealData = new BasicMLData(idealCount);
for (int j = 0; j < idealCount; j++)
{
idealData[j] = rand.Range(min, max);
}
var pair = new BasicMLDataPair(inputData,
idealData);
result.Add(pair);
}
return(result);
}
/// <summary>
/// Processes the specified double serie into an IMLDataset.
/// To use this method, you must provide a formated double array with the input data and the ideal data in another double array.
/// The number of points in the input window makes the input array , and the predict window will create the array used in ideal.
/// This method will use ALL the data inputs and ideals you have provided.
/// </summary>
/// <param name="datainput">The datainput.</param>
/// <param name="ideals">The ideals.</param>
/// <param name="_inputWindow">The _input window.</param>
/// <param name="_predictWindow">The _predict window.</param>
/// <returns></returns>
public static IMLDataSet ProcessDoubleSerieIntoIMLDataset(List <double> datainput, List <double> ideals, int _inputWindow, int _predictWindow)
{
var result = new BasicMLDataSet();
//int count = 0;
////lets check if there is a modulo , if so we move forward in the List of doubles in inputs.This is just a check
////as the data of inputs should be able to fill without having .
//while (datainput.Count % _inputWindow !=0)
//{
// count++;
//}
var inputData = new BasicMLData(_inputWindow);
var idealData = new BasicMLData(_predictWindow);
foreach (double d in datainput)
{
// handle input window
for (int j = 0; j < _inputWindow; j++)
{
inputData[j] = d;
}
}
foreach (double ideal in ideals)
{
// handle predict window
for (int j = 0; j < _predictWindow; j++)
{
idealData[j] = ideal;
}
}
var pair = new BasicMLDataPair(inputData, idealData);
result.Add(pair);
return(result);
}
/// <summary>
/// Generate random training into a training set.
/// </summary>
/// <param name="training">The training set to generate into.</param>
/// <param name="seed">The seed to use.</param>
/// <param name="count">How much data to generate.</param>
/// <param name="min">The low random value.</param>
/// <param name="max">The high random value.</param>
public static void Generate(IMLDataSetAddable training,
long seed,
int count,
double min, double max)
{
var rand
= new LinearCongruentialGenerator(seed);
int inputCount = training.InputSize;
int idealCount = training.IdealSize;
for (int i = 0; i < count; i++)
{
var inputData = new BasicMLData(inputCount);
for (int j = 0; j < inputCount; j++)
{
inputData[j] = rand.Range(min, max);
}
var idealData = new BasicMLData(idealCount);
for (int j = 0; j < idealCount; j++)
{
idealData[j] = rand.Range(min, max);
}
var pair = new BasicMLDataPair(inputData,
idealData);
training.Add(pair);
}
}
/// <inheritdoc/>
public void Write(double[] input, double[] ideal, double significance)
{
IMLDataPair pair = BasicMLDataPair.CreatePair(_inputSize,
_idealSize);
EngineArray.ArrayCopy(input, pair.Input.Data);
EngineArray.ArrayCopy(ideal, pair.Ideal.Data);
pair.Significance = significance;
}
/// <summary>
/// Evaluate disk.
/// </summary>
private void EvalBinary()
{
FileInfo file = FileUtil.CombinePath(new FileInfo(Path.GetTempPath()), "temp.egb");
BasicMLDataSet training = RandomTrainingFactory.Generate(
1000, 10000, 10, 10, -1, 1);
// create the binary file
if (file.Exists)
{
file.Delete();
}
var training2 = new BufferedMLDataSet(file.ToString());
training2.Load(training);
const long stop = (10 * Evaluate.Milis);
int record = 0;
IMLDataPair pair = BasicMLDataPair.CreatePair(10, 10);
var watch = new Stopwatch();
watch.Start();
int iterations = 0;
while (watch.ElapsedMilliseconds < stop)
{
iterations++;
training2.GetRecord(record++, pair);
if (record >= training2.Count)
{
record = 0;
}
}
training2.Close();
iterations /= 100000;
_report.Report(Steps, Step3,
"Disk(binary) dataset, result: "
+ Format.FormatInteger(iterations));
if (file.Exists)
{
file.Delete();
}
_binaryScore = iterations;
}
/// <summary>
/// Move to the next record.
/// </summary>
/// <returns>True, if we were able to move to the next record.</returns>
public bool MoveNext()
{
if (HasNext())
{
IMLDataPair pair = BasicMLDataPair.CreatePair(
_owner.InputSize, _owner.IdealSize);
_owner.GetRecord(_currentIndex++, pair);
_currentPair = pair;
return(true);
}
_currentPair = null;
return(false);
}
/// <summary>
/// Get the minimum, over all the data, for the specified index.
/// </summary>
///
/// <param name="index">An index into the input data.</param>
/// <returns>The minimum value.</returns>
private double GetMinValue(int index)
{
double result = Double.MaxValue;
long count = _set.Count;
IMLDataPair pair = BasicMLDataPair.CreatePair(
_set.InputSize, _set.IdealSize);
for (int i = 0; i < count; i++)
{
_set.GetRecord(index, pair);
result = Math.Min(result, pair.InputArray[index]);
}
return(result);
}
public void Update(State s, double value)
{
var pair = new BasicMLDataPair(new BasicMLData(s.AsDoubles()), new BasicMLData(new double[] { value }));
var trainingSet = new BasicMLDataSet(new[] { pair });
var train = new Encog.Neural.Networks.Training.Propagation.Back.Backpropagation(_network, trainingSet);
train.BatchSize = 1;
train.Iteration(2);
if (train.Error > 0.01)
{
train.Iteration(3);
}
}
/// <summary>
/// Calculate the error for this neural network. The error is calculated
/// using root-mean-square(RMS).
/// </summary>
///
/// <param name="data">The training set.</param>
/// <returns>The error percentage.</returns>
public double CalculateError(IMLDataSet data)
{
var errorCalculation = new ErrorCalculation();
var actual = new double[_outputCount];
IMLDataPair pair = BasicMLDataPair.CreatePair(data.InputSize,
data.IdealSize);
for (int i = 0; i < data.Count; i++)
{
data.GetRecord(i, pair);
Compute(pair.InputArray, actual);
errorCalculation.UpdateError(actual, pair.IdealArray, pair.Significance);
}
return(errorCalculation.Calculate());
}
/// <summary>
/// Convert an external file format, such as CSV, to an Encog memory training set.
/// </summary>
public IMLDataSet External2Memory()
{
Status.Report(0, 0, "Importing to memory");
if (Result == null)
{
Result = new BasicMLDataSet();
}
var input = new double[_codec.InputSize];
var ideal = new double[_codec.IdealSize];
_codec.PrepareRead();
int currentRecord = 0;
int lastUpdate = 0;
double significance = 1.0;
while (_codec.Read(input, ideal, ref significance))
{
IMLData b = null;
IMLData a = new BasicMLData(input);
if (_codec.IdealSize > 0)
{
b = new BasicMLData(ideal);
}
IMLDataPair pair = new BasicMLDataPair(a, b);
pair.Significance = significance;
Result.Add(pair);
currentRecord++;
lastUpdate++;
if (lastUpdate >= 10000)
{
lastUpdate = 0;
Status.Report(0, currentRecord, "Importing...");
}
}
_codec.Close();
Status.Report(0, 0, "Done importing to memory");
return(Result);
}
public static IMLDataSet CreateNoisyXORDataSet(int count)
{
var result = new BasicMLDataSet();
for (int i = 0; i < count; i++)
{
for (int j = 0; j < 4; j++)
{
var inputData = new BasicMLData(XORInput[j]);
var idealData = new BasicMLData(XORIdeal[j]);
var pair = new BasicMLDataPair(inputData, idealData);
inputData[0] = inputData[0] + RangeRandomizer.Randomize(-0.1, 0.1);
inputData[1] = inputData[1] + RangeRandomizer.Randomize(-0.1, 0.1);
result.Add(pair);
}
}
return(result);
}
/// <inheritdoc/>
public IMLDataPair this[int x]
{
get
{
var input = new double[InputSize];
var ideal = new double[IdealSize];
_egb.SetLocation(x);
_egb.Read(input);
_egb.Read(ideal);
var inputData = new BasicMLData(input, false);
var idealData = new BasicMLData(ideal, false);
var result = new BasicMLDataPair(inputData, idealData);
result.Significance = _egb.Read();
return(result);
}
}
/// <summary>
/// Move to the next element.
/// </summary>
/// <returns>True if there are more elements to read.</returns>
public bool MoveNext()
{
try
{
if (_current >= _data.Count)
{
return(false);
}
_currentRecord = BasicMLDataPair.CreatePair(_data
.InputSize, _data.IdealSize);
_data.GetRecord(_current++, _currentRecord);
return(true);
}
catch (EndOfStreamException)
{
return(false);
}
}
/// <inheritdoc />
public IMLDataPair this[int index]
{
get
{
if (index > Count)
{
return(null);
}
var input = new BasicMLData(
CalculatedInputSize * CalculateLagCount());
var ideal = new BasicMLData(
CalculatedIdealSize * CalculateLeadCount());
IMLDataPair pair = new BasicMLDataPair(input, ideal);
GetRecord(index, pair);
return(pair);
}
}
/// <summary>
/// Construct the chain rule worker.
/// </summary>
/// <param name="theNetwork">The network to calculate a Hessian for.</param>
/// <param name="theTraining">The training data.</param>
/// <param name="theLow">The low range.</param>
/// <param name="theHigh">The high range.</param>
public ChainRuleWorker(FlatNetwork theNetwork, IMLDataSet theTraining, int theLow, int theHigh)
{
int weightCount = theNetwork.Weights.Length;
_training = theTraining;
_flat = theNetwork;
_layerDelta = new double[_flat.LayerOutput.Length];
_actual = new double[_flat.OutputCount];
_derivative = new double[weightCount];
_totDeriv = new double[weightCount];
_gradients = new double[weightCount];
_weights = _flat.Weights;
_layerIndex = _flat.LayerIndex;
_layerCounts = _flat.LayerCounts;
_weightIndex = _flat.WeightIndex;
_layerOutput = _flat.LayerOutput;
_layerSums = _flat.LayerSums;
_layerFeedCounts = _flat.LayerFeedCounts;
_low = theLow;
_high = theHigh;
_pair = BasicMLDataPair.CreatePair(_flat.InputCount, _flat.OutputCount);
}
/// <summary>
/// Loads variables inputs and one ideal double series into an imldataset.
/// </summary>
/// <param name="idealsinputs"></param>
/// <param name="WindoSize"></param>
/// <param name="pparamInputs"></param>
/// <returns></returns>
public static Tuple <IMLDataSet, NormalizeArray> Load(double[] idealsinputs, int WindoSize, params double[][] pparamInputs)
{
try
{
var finalSet = new BasicMLDataSet();
//We make a dic with the count of inputs being the number of double series we are sending in.
Dictionary <int, double[]> inputsDics = new Dictionary <int, double[]>(pparamInputs.Length);
int indexS = 0;
//We make a normalizeArray which we will return as a tuple ready for denormalization.
NormalizeArray Normer = new NormalizeArray(-1, 1);
//Process each inputs.
foreach (double[] doubleSeries in pparamInputs)
{
inputsDics.Add(indexS++, Normer.Process(doubleSeries));
}
//Process the ideals.
var idealNormed = Normer.Process(idealsinputs);
//Make a list which will hold the inputs one after the others
List <double> dtda = new List <double>();
int listindex = 0;
int currentindex = 0;
//starts from zero so count -1..
int dicinputsCount = inputsDics.Keys.Count - 1;
//Process the input normed.
foreach (double d in inputsDics[0])
{
if (currentindex++ < WindoSize)
{
dtda.Add(d);
//we put all the fields which are in the dic.
while (dicinputsCount > 0)
{
dtda.Add(inputsDics[dicinputsCount--][listindex]);
}
//We reset the field count for a later pass.
dicinputsCount = inputsDics.Keys.Count - 1;
}
if (currentindex == WindoSize)
{
//Make an imldata pair, and add it to the imldataset...reset the temp list of inputs...
var pair = new BasicMLDataPair(
new BasicMLData(dtda.ToArray()),
new BasicMLData(new double[] { idealNormed[listindex] }));
currentindex = 0;
dtda.Clear();
finalSet.Add(pair);
}
//Lets increment the indexes..
listindex++;
}
//Return the dataset and the normalization array..
return(new Tuple <IMLDataSet, NormalizeArray>(finalSet, Normer));
}
catch (Exception ex)
{
Console.WriteLine("Got an error : ", ex);
throw new Exception("Error parsing points....");
}
}
/// <summary>
/// Compute the derivative for target data.
/// </summary>
///
/// <param name="input">The input.</param>
/// <param name="target">The target data.</param>
/// <returns>The output.</returns>
public IMLData ComputeDeriv(IMLData input, IMLData target)
{
int pop, ivar;
int ibest = 0;
int outvar;
double dist, truedist;
double vtot, wtot;
double temp, der1, der2, psum;
int vptr, wptr, vsptr = 0, wsptr = 0;
var xout = new double[_network.OutputCount];
for (pop = 0; pop < _network.OutputCount; pop++)
{
xout[pop] = 0.0d;
for (ivar = 0; ivar < _network.InputCount; ivar++)
{
_v[pop * _network.InputCount + ivar] = 0.0d;
_w[pop * _network.InputCount + ivar] = 0.0d;
}
}
psum = 0.0d;
if (_network.OutputMode != PNNOutputMode.Classification)
{
vsptr = _network.OutputCount
* _network.InputCount;
wsptr = _network.OutputCount
* _network.InputCount;
for (ivar = 0; ivar < _network.InputCount; ivar++)
{
_v[vsptr + ivar] = 0.0d;
_w[wsptr + ivar] = 0.0d;
}
}
IMLDataPair pair = BasicMLDataPair.CreatePair(_network.Samples.InputSize, _network.Samples.IdealSize);
for (int r = 0; r < _network.Samples.Count; r++)
{
_network.Samples.GetRecord(r, pair);
if (r == _network.Exclude)
{
continue;
}
dist = 0.0d;
for (ivar = 0; ivar < _network.InputCount; ivar++)
{
double diff = input[ivar] - pair.Input[ivar];
diff /= _network.Sigma[ivar];
_dsqr[ivar] = diff * diff;
dist += _dsqr[ivar];
}
if (_network.Kernel == PNNKernelType.Gaussian)
{
dist = Math.Exp(-dist);
}
else if (_network.Kernel == PNNKernelType.Reciprocal)
{
dist = 1.0d / (1.0d + dist);
}
truedist = dist;
if (dist < 1.0e-40d)
{
dist = 1.0e-40d;
}
if (_network.OutputMode == PNNOutputMode.Classification)
{
pop = (int)pair.Ideal[0];
xout[pop] += dist;
vptr = pop * _network.InputCount;
wptr = pop * _network.InputCount;
for (ivar = 0; ivar < _network.InputCount; ivar++)
{
temp = truedist * _dsqr[ivar];
_v[vptr + ivar] += temp;
_w[wptr + ivar] += temp * (2.0d * _dsqr[ivar] - 3.0d);
}
}
else if (_network.OutputMode == PNNOutputMode.Unsupervised)
{
for (ivar = 0; ivar < _network.InputCount; ivar++)
{
xout[ivar] += dist * pair.Input[ivar];
temp = truedist * _dsqr[ivar];
_v[vsptr + ivar] += temp;
_w[wsptr + ivar] += temp
* (2.0d * _dsqr[ivar] - 3.0d);
}
vptr = 0;
wptr = 0;
for (outvar = 0; outvar < _network.OutputCount; outvar++)
{
for (ivar = 0; ivar < _network.InputCount; ivar++)
{
temp = truedist * _dsqr[ivar]
* pair.Input[ivar];
_v[vptr++] += temp;
_w[wptr++] += temp * (2.0d * _dsqr[ivar] - 3.0d);
}
}
psum += dist;
}
else if (_network.OutputMode == PNNOutputMode.Regression)
{
for (ivar = 0; ivar < _network.OutputCount; ivar++)
{
xout[ivar] += dist * pair.Ideal[ivar];
}
vptr = 0;
wptr = 0;
for (outvar = 0; outvar < _network.OutputCount; outvar++)
{
for (ivar = 0; ivar < _network.InputCount; ivar++)
{
temp = truedist * _dsqr[ivar]
* pair.Ideal[outvar];
_v[vptr++] += temp;
_w[wptr++] += temp * (2.0d * _dsqr[ivar] - 3.0d);
}
}
for (ivar = 0; ivar < _network.InputCount; ivar++)
{
temp = truedist * _dsqr[ivar];
_v[vsptr + ivar] += temp;
_w[wsptr + ivar] += temp
* (2.0d * _dsqr[ivar] - 3.0d);
}
psum += dist;
}
}
if (_network.OutputMode == PNNOutputMode.Classification)
{
psum = 0.0d;
for (pop = 0; pop < _network.OutputCount; pop++)
{
if (_network.Priors[pop] >= 0.0d)
{
xout[pop] *= _network.Priors[pop]
/ _network.CountPer[pop];
}
psum += xout[pop];
}
if (psum < 1.0e-40d)
{
psum = 1.0e-40d;
}
}
for (pop = 0; pop < _network.OutputCount; pop++)
{
xout[pop] /= psum;
}
for (ivar = 0; ivar < _network.InputCount; ivar++)
{
if (_network.OutputMode == PNNOutputMode.Classification)
{
vtot = wtot = 0.0d;
}
else
{
vtot = _v[vsptr + ivar] * 2.0d
/ (psum * _network.Sigma[ivar]);
wtot = _w[wsptr + ivar]
* 2.0d
/ (psum * _network.Sigma[ivar] * _network.Sigma[ivar]);
}
for (outvar = 0; outvar < _network.OutputCount; outvar++)
{
if ((_network.OutputMode == PNNOutputMode.Classification) &&
(_network.Priors[outvar] >= 0.0d))
{
_v[outvar * _network.InputCount + ivar] *= _network.Priors[outvar]
/ _network.CountPer[outvar];
_w[outvar * _network.InputCount + ivar] *= _network.Priors[outvar]
/ _network.CountPer[outvar];
}
_v[outvar * _network.InputCount + ivar] *= 2.0d / (psum * _network.Sigma[ivar]);
_w[outvar * _network.InputCount + ivar] *= 2.0d / (psum
* _network.Sigma[ivar] * _network.Sigma[ivar]);
if (_network.OutputMode == PNNOutputMode.Classification)
{
vtot += _v[outvar * _network.InputCount + ivar];
wtot += _w[outvar * _network.InputCount + ivar];
}
}
for (outvar = 0; outvar < _network.OutputCount; outvar++)
{
der1 = _v[outvar * _network.InputCount + ivar]
- xout[outvar] * vtot;
der2 = _w[outvar * _network.InputCount + ivar]
+ 2.0d * xout[outvar] * vtot * vtot - 2.0d
* _v[outvar * _network.InputCount + ivar]
* vtot - xout[outvar] * wtot;
if (_network.OutputMode == PNNOutputMode.Classification)
{
if (outvar == (int)target[0])
{
temp = 2.0d * (xout[outvar] - 1.0d);
}
else
{
temp = 2.0d * xout[outvar];
}
}
else
{
temp = 2.0d * (xout[outvar] - target[outvar]);
}
_network.Deriv[ivar] += temp * der1;
_network.Deriv2[ivar] += temp * der2 + 2.0d * der1
* der1;
}
}
if (_network.OutputMode == PNNOutputMode.Classification)
{
IMLData result = new BasicMLData(1);
result[0] = ibest;
return(result);
}
return(null);
}
/// <summary>
/// Calculate the error for the entire training set.
/// </summary>
///
/// <param name="training">Training set to use.</param>
/// <param name="deriv">Should we find the derivative.</param>
/// <returns>The error.</returns>
public double CalculateError(IMLDataSet training,
bool deriv)
{
double totErr;
double diff;
totErr = 0.0d;
if (deriv)
{
int num = (_network.SeparateClass)
? _network.InputCount * _network.OutputCount
: _network.InputCount;
for (int i = 0; i < num; i++)
{
_network.Deriv[i] = 0.0d;
_network.Deriv2[i] = 0.0d;
}
}
_network.Exclude = (int)training.Count;
IMLDataPair pair = BasicMLDataPair.CreatePair(
training.InputSize, training.IdealSize);
var xout = new double[_network.OutputCount];
for (int r = 0; r < training.Count; r++)
{
training.GetRecord(r, pair);
_network.Exclude = _network.Exclude - 1;
double err = 0.0d;
IMLData input = pair.Input;
IMLData target = pair.Ideal;
if (_network.OutputMode == PNNOutputMode.Unsupervised)
{
if (deriv)
{
IMLData output = ComputeDeriv(input, target);
for (int z = 0; z < _network.OutputCount; z++)
{
xout[z] = output[z];
}
}
else
{
IMLData output = _network.Compute(input);
for (int z = 0; z < _network.OutputCount; z++)
{
xout[z] = output[z];
}
}
for (int i = 0; i < _network.OutputCount; i++)
{
diff = input[i] - xout[i];
err += diff * diff;
}
}
else if (_network.OutputMode == PNNOutputMode.Classification)
{
var tclass = (int)target[0];
IMLData output;
if (deriv)
{
output = ComputeDeriv(input, pair.Ideal);
//output_4.GetData(0); //**FIX**?
}
else
{
output = _network.Compute(input);
//output_4.GetData(0); **FIX**?
}
xout[0] = output[0];
for (int i = 0; i < xout.Length; i++)
{
if (i == tclass)
{
diff = 1.0d - xout[i];
err += diff * diff;
}
else
{
err += xout[i] * xout[i];
}
}
}
else if (_network.OutputMode == PNNOutputMode.Regression)
{
if (deriv)
{
IMLData output = _network.Compute(input);
for (int z = 0; z < _network.OutputCount; z++)
{
xout[z] = output[z];
}
}
else
{
IMLData output = _network.Compute(input);
for (int z = 0; z < _network.OutputCount; z++)
{
xout[z] = output[z];
}
}
for (int i = 0; i < _network.OutputCount; i++)
{
diff = target[i] - xout[i];
err += diff * diff;
}
}
totErr += err;
}
_network.Exclude = -1;
_network.Error = totErr / training.Count;
if (deriv)
{
for (int i = 0; i < _network.Deriv.Length; i++)
{
_network.Deriv[i] /= training.Count;
_network.Deriv2[i] /= training.Count;
}
}
if ((_network.OutputMode == PNNOutputMode.Unsupervised) ||
(_network.OutputMode == PNNOutputMode.Regression))
{
_network.Error = _network.Error
/ _network.OutputCount;
if (deriv)
{
for (int i = 0; i < _network.InputCount; i++)
{
_network.Deriv[i] /= _network.OutputCount;
_network.Deriv2[i] /= _network.OutputCount;
}
}
}
return(_network.Error);
}
/// <summary>
/// Read an object.
/// </summary>
public Object Read(Stream mask0)
{
var ins0 = new EncogReadHelper(mask0);
EncogFileSection section;
var samples = new BasicMLDataSet();
IDictionary <String, String> networkParams = null;
PNNKernelType kernel = default(PNNKernelType) /* was: null */;
PNNOutputMode outmodel = default(PNNOutputMode) /* was: null */;
int inputCount = 0;
int outputCount = 0;
double error = 0;
double[] sigma = null;
while ((section = ins0.ReadNextSection()) != null)
{
if (section.SectionName.Equals("PNN") &&
section.SubSectionName.Equals("PARAMS"))
{
networkParams = section.ParseParams();
}
if (section.SectionName.Equals("PNN") &&
section.SubSectionName.Equals("NETWORK"))
{
IDictionary <String, String> paras = section.ParseParams();
inputCount = EncogFileSection.ParseInt(paras,
PersistConst.InputCount);
outputCount = EncogFileSection.ParseInt(paras,
PersistConst.OutputCount);
kernel = StringToKernel(paras[PersistConst.Kernel]);
outmodel = StringToOutputMode(paras[PropertyOutputMode]);
error = EncogFileSection
.ParseDouble(paras, PersistConst.Error);
sigma = section.ParseDoubleArray(paras, PersistConst.Sigma);
}
if (section.SectionName.Equals("PNN") &&
section.SubSectionName.Equals("SAMPLES"))
{
foreach (String line in section.Lines)
{
IList <String> cols = EncogFileSection
.SplitColumns(line);
int index = 0;
var inputData = new BasicMLData(inputCount);
for (int i = 0; i < inputCount; i++)
{
inputData[i] =
CSVFormat.EgFormat.Parse(cols[index++]);
}
var idealData = new BasicMLData(inputCount);
idealData[0] = CSVFormat.EgFormat.Parse(cols[index++]);
IMLDataPair pair = new BasicMLDataPair(inputData,
idealData);
samples.Add(pair);
}
}
}
var result = new BasicPNN(kernel, outmodel, inputCount,
outputCount);
if (networkParams != null)
{
EngineArray.PutAll(networkParams, result.Properties);
}
result.Samples = samples;
result.Error = error;
if (sigma != null)
{
EngineArray.ArrayCopy(sigma, result.Sigma);
}
return(result);
}
