public void TestClassifyPNN()
{
PNNOutputMode mode = PNNOutputMode.Classification;
BasicPNN network = new BasicPNN(PNNKernelType.Gaussian, mode, 2, 2);
IMLDataSet trainingData = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal);
TrainBasicPNN train = new TrainBasicPNN(network, trainingData);
train.Iteration();
XOR.VerifyXOR(network, 0.01);
}
public BasicPNN create()
{
PNNOutputMode mode = PNNOutputMode.Regression;
BasicPNN network = new BasicPNN(PNNKernelType.Gaussian, mode, 2, 1);
BasicMLDataSet trainingSet = new BasicMLDataSet(XOR.XORInput,
XOR.XORIdeal);
TrainBasicPNN train = new TrainBasicPNN(network, trainingSet);
train.Iteration();
XOR.VerifyXOR(network, 0.001);
return network;
}
/// <summary>
/// Generate the RSOM network.
/// </summary>
///
/// <returns>The neural network.</returns>
public IMLMethod Generate()
{
var pnn = new BasicPNN(_kernel, _outmodel,
_inputNeurons, _outputNeurons);
return pnn;
}
/// <summary>
/// Create a PNN network.
/// </summary>
///
/// <param name="architecture">THe architecture string to use.</param>
/// <param name="input">The input count.</param>
/// <param name="output">The output count.</param>
/// <returns>The RBF network.</returns>
public IMLMethod Create(String architecture, int input,
int output)
{
IList<String> layers = ArchitectureParse.ParseLayers(architecture);
if (layers.Count != MaxLayers)
{
throw new EncogError(
"PNN Networks must have exactly three elements, "
+ "separated by ->.");
}
ArchitectureLayer inputLayer = ArchitectureParse.ParseLayer(
layers[0], input);
ArchitectureLayer pnnLayer = ArchitectureParse.ParseLayer(
layers[1], -1);
ArchitectureLayer outputLayer = ArchitectureParse.ParseLayer(
layers[2], output);
int inputCount = inputLayer.Count;
int outputCount = outputLayer.Count;
PNNKernelType kernel;
PNNOutputMode outmodel;
if (pnnLayer.Name.Equals("c", StringComparison.InvariantCultureIgnoreCase))
{
outmodel = PNNOutputMode.Classification;
}
else if (pnnLayer.Name.Equals("r", StringComparison.InvariantCultureIgnoreCase))
{
outmodel = PNNOutputMode.Regression;
}
else if (pnnLayer.Name.Equals("u", StringComparison.InvariantCultureIgnoreCase))
{
outmodel = PNNOutputMode.Unsupervised;
}
else
{
throw new NeuralNetworkError("Unknown model: " + pnnLayer.Name);
}
var holder = new ParamsHolder(pnnLayer.Params);
String kernelStr = holder.GetString("KERNEL", false, "gaussian");
if (kernelStr.Equals("gaussian", StringComparison.InvariantCultureIgnoreCase))
{
kernel = PNNKernelType.Gaussian;
}
else if (kernelStr.Equals("reciprocal", StringComparison.InvariantCultureIgnoreCase))
{
kernel = PNNKernelType.Reciprocal;
}
else
{
throw new NeuralNetworkError("Unknown kernel: " + kernelStr);
}
var result = new BasicPNN(kernel, outmodel, inputCount,
outputCount);
return result;
}
/// <summary>
/// Train a BasicPNN.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
public TrainBasicPNN(BasicPNN network, IMLDataSet training)
: base(TrainingImplementationType.OnePass)
{
_network = network;
_training = training;
_maxError = DefaultMaxError;
_minImprovement = DefaultMinImprovement;
_sigmaLow = DefaultSigmaLow;
_sigmaHigh = DefaultSigmaHigh;
_numSigmas = DefaultNumSigmas;
_samplesLoaded = false;
}
/// <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;
}
public object Read(Stream mask0)
{
EncogFileSection section;
double num3;
double[] numArray;
IDictionary<string, string> dictionary2;
int num4;
int num5;
int num6;
BasicPNN cpnn;
EncogReadHelper helper = new EncogReadHelper(mask0);
BasicMLDataSet set = new BasicMLDataSet();
IDictionary<string, string> source = null;
PNNKernelType gaussian = PNNKernelType.Gaussian;
PNNOutputMode unsupervised = PNNOutputMode.Unsupervised;
int inputCount = 0;
int outputCount = 0;
goto Label_042A;
Label_000C:
cpnn.Error = num3;
while (numArray != null)
{
EngineArray.ArrayCopy(numArray, cpnn.Sigma);
return cpnn;
}
if ((((uint) num3) - ((uint) outputCount)) <= uint.MaxValue)
{
if ((((uint) num5) - ((uint) outputCount)) >= 0)
{
return cpnn;
}
if ((((uint) inputCount) - ((uint) inputCount)) >= 0)
{
goto Label_0319;
}
if (((uint) num4) >= 0)
{
goto Label_02F1;
}
goto Label_02BB;
}
goto Label_00D8;
Label_0075:
while (source != null)
{
EngineArray.PutAll<string, string>(source, cpnn.Properties);
if ((((uint) outputCount) + ((uint) num3)) >= 0)
{
break;
}
}
cpnn.Samples = set;
goto Label_00A5;
Label_0082:
if ((section = helper.ReadNextSection()) != null)
{
if (section.SectionName.Equals("PNN") && (((((uint) num4) & 0) != 0) || section.SubSectionName.Equals("PARAMS")))
{
source = section.ParseParams();
}
if (section.SectionName.Equals("PNN") && section.SubSectionName.Equals("NETWORK"))
{
dictionary2 = section.ParseParams();
if ((((uint) outputCount) + ((uint) num6)) <= uint.MaxValue)
{
inputCount = EncogFileSection.ParseInt(dictionary2, "inputCount");
outputCount = EncogFileSection.ParseInt(dictionary2, "outputCount");
}
gaussian = StringToKernel(dictionary2["kernel"]);
if (0 != 0)
{
return cpnn;
}
unsupervised = StringToOutputMode(dictionary2["outputMode"]);
goto Label_0319;
}
goto Label_02BB;
}
cpnn = new BasicPNN(gaussian, unsupervised, inputCount, outputCount);
if (4 != 0)
{
goto Label_0075;
}
Label_00A5:
if ((((uint) outputCount) | 15) != 0)
{
goto Label_000C;
}
goto Label_0082;
Label_00D8:
if (0 != 0)
{
goto Label_042A;
}
if ((((uint) num3) | 1) != 0)
{
goto Label_0082;
}
goto Label_000C;
Label_02BB:
if (section.SectionName.Equals("PNN"))
{
if (((uint) inputCount) > uint.MaxValue)
{
goto Label_0075;
}
if (section.SubSectionName.Equals("SAMPLES"))
{
using (IEnumerator<string> enumerator = section.Lines.GetEnumerator())
{
string str;
IList<string> list;
IMLData data;
IMLData data2;
IMLDataPair pair;
goto Label_0193;
Label_0174:
set.Add(pair);
if ((((uint) num4) & 0) != 0)
{
goto Label_0206;
}
Label_0193:
if (enumerator.MoveNext())
{
goto Label_0255;
}
goto Label_0082;
Label_01A1:
data2[num6] = CSVFormat.EgFormat.Parse(list[num4++]);
num6++;
Label_01C8:
if (num6 < outputCount)
{
goto Label_01A1;
}
pair = new BasicMLDataPair(data, data2);
if (((uint) num3) >= 0)
{
goto Label_0174;
}
goto Label_0082;
Label_01ED:
if (((uint) num5) > uint.MaxValue)
{
goto Label_0238;
}
num6 = 0;
goto Label_01C8;
Label_0206:
num5 = 0;
while (num5 < inputCount)
{
data[num5] = CSVFormat.EgFormat.Parse(list[num4++]);
num5++;
}
Label_0238:
data2 = new BasicMLData(inputCount);
goto Label_01ED;
Label_0245:
num4 = 0;
data = new BasicMLData(inputCount);
goto Label_0206;
Label_0255:
str = enumerator.Current;
list = EncogFileSection.SplitColumns(str);
if ((((uint) num6) + ((uint) num4)) <= uint.MaxValue)
{
goto Label_0245;
}
goto Label_0082;
}
if ((((uint) inputCount) + ((uint) num5)) <= uint.MaxValue)
{
if ((((uint) outputCount) + ((uint) num6)) <= uint.MaxValue)
{
goto Label_033B;
}
goto Label_0319;
}
goto Label_02F1;
}
}
goto Label_0082;
Label_02F1:
numArray = EncogFileSection.ParseDoubleArray(dictionary2, "sigma");
goto Label_02BB;
Label_0319:
num3 = EncogFileSection.ParseDouble(dictionary2, "error");
if ((((uint) inputCount) & 0) == 0)
{
goto Label_02F1;
}
Label_033B:
if ((((uint) inputCount) & 0) == 0)
{
goto Label_00D8;
}
return cpnn;
Label_042A:
num3 = 0.0;
numArray = null;
if ((((uint) num4) - ((uint) num6)) < 0)
{
goto Label_0075;
}
goto Label_0082;
}
