/// <summary>
/// Construct the training object.
/// </summary>
///
/// <param name="network_0">The network to train. Must have a single output neuron.</param>
/// <param name="training">The training data to use. Must be indexable.</param>
public SVDTraining(RBFNetwork network_0, IMLDataSet training) : base(TrainingImplementationType.OnePass)
{
if (network_0.OutputCount != 1)
{
throw new TrainingError(
"SVD requires an output layer with a single neuron.");
}
Training = training;
network = network_0;
}
public void TestPersistEG()
{
IMLDataSet trainingSet = XOR.CreateXORDataSet();
RBFNetwork network = new RBFNetwork(2, 4, 1, RBFEnum.Gaussian);
SVDTraining training = new SVDTraining(network, trainingSet);
training.Iteration();
XOR.VerifyXOR(network, 0.1);
EncogDirectoryPersistence.SaveObject(EG_FILENAME, network);
RBFNetwork network2 = (RBFNetwork)EncogDirectoryPersistence.LoadObject(EG_FILENAME);
XOR.VerifyXOR(network2, 0.1);
}
public SVDTraining(RBFNetwork network_0, IMLDataSet training)
: base(TrainingImplementationType.OnePass)
{
while (-2147483648 != 0)
{
if (network_0.OutputCount != 1)
{
break;
}
this.Training = training;
this.x87a7fc6a72741c2e = network_0;
if (0 != 0)
{
break;
}
return;
}
throw new TrainingError("SVD requires an output layer with a single neuron.");
}
/// <summary>
/// Create the SRN.
/// </summary>
///
/// <param name="architecture">The architecture string.</param>
/// <param name="input">The input count.</param>
/// <param name="output">The output count.</param>
/// <returns>The newly created SRN.</returns>
public IMLMethod Create(String architecture, int input,
int output)
{
IList<String> layers = ArchitectureParse.ParseLayers(architecture);
if (layers.Count != MaxLayers)
{
throw new EncogError(
"SRN Networks must have exactly three elements, "
+ "separated by ->.");
}
ArchitectureLayer inputLayer = ArchitectureParse.ParseLayer(
layers[0], input);
ArchitectureLayer rbfLayer = ArchitectureParse.ParseLayer(
layers[1], -1);
ArchitectureLayer outputLayer = ArchitectureParse.ParseLayer(
layers[2], output);
int inputCount = inputLayer.Count;
int outputCount = outputLayer.Count;
RBFEnum t;
if (rbfLayer.Name.Equals("Gaussian", StringComparison.InvariantCultureIgnoreCase))
{
t = RBFEnum.Gaussian;
}
else if (rbfLayer.Name.Equals("Multiquadric", StringComparison.InvariantCultureIgnoreCase))
{
t = RBFEnum.Multiquadric;
}
else if (rbfLayer.Name.Equals("InverseMultiquadric", StringComparison.InvariantCultureIgnoreCase))
{
t = RBFEnum.InverseMultiquadric;
}
else if (rbfLayer.Name.Equals("MexicanHat", StringComparison.InvariantCultureIgnoreCase))
{
t = RBFEnum.MexicanHat;
}
else
{
t = RBFEnum.Gaussian;
}
var result = new RBFNetwork(inputCount,
rbfLayer.Count, outputCount, t);
return result;
}
/// <summary>
/// Generate the RBF network.
/// </summary>
///
/// <returns>The neural network.</returns>
public IMLMethod Generate()
{
var result = new RBFNetwork(_inputNeurons, _hiddenNeurons,
_outputNeurons, _rbfType);
return result;
}
/// <inheritdoc/>
public Object Read(Stream mask0)
{
var result = new RBFNetwork();
var flat = (FlatNetworkRBF) result.Flat;
var ins0 = new EncogReadHelper(mask0);
EncogFileSection section;
while ((section = ins0.ReadNextSection()) != null)
{
if (section.SectionName.Equals("RBF-NETWORK")
&& section.SubSectionName.Equals("PARAMS"))
{
IDictionary<String, String> paras = section.ParseParams();
EngineArray.PutAll(paras, result.Properties);
}
if (section.SectionName.Equals("RBF-NETWORK")
&& section.SubSectionName.Equals("NETWORK"))
{
IDictionary<String, String> p = section.ParseParams();
flat.BeginTraining = EncogFileSection.ParseInt(p,
BasicNetwork.TagBeginTraining);
flat.ConnectionLimit = EncogFileSection.ParseDouble(p,
BasicNetwork.TagConnectionLimit);
flat.ContextTargetOffset = EncogFileSection.ParseIntArray(
p, BasicNetwork.TagContextTargetOffset);
flat.ContextTargetSize = EncogFileSection.ParseIntArray(
p, BasicNetwork.TagContextTargetSize);
flat.EndTraining = EncogFileSection.ParseInt(p,
BasicNetwork.TagEndTraining);
flat.HasContext = EncogFileSection.ParseBoolean(p,
BasicNetwork.TagHasContext);
flat.InputCount = EncogFileSection.ParseInt(p,
PersistConst.InputCount);
flat.LayerCounts = EncogFileSection.ParseIntArray(p,
BasicNetwork.TagLayerCounts);
flat.LayerFeedCounts = EncogFileSection.ParseIntArray(p,
BasicNetwork.TagLayerFeedCounts);
flat.LayerContextCount = EncogFileSection.ParseIntArray(p, BasicNetwork.TagLayerContextCount);
flat.LayerIndex = EncogFileSection.ParseIntArray(p,
BasicNetwork.TagLayerIndex);
flat.LayerOutput = section.ParseDoubleArray(p,
PersistConst.Output);
flat.LayerSums = new double[flat.LayerOutput.Length];
flat.OutputCount = EncogFileSection.ParseInt(p,PersistConst.OutputCount);
flat.WeightIndex = EncogFileSection.ParseIntArray(p,
BasicNetwork.TagWeightIndex);
flat.Weights = section.ParseDoubleArray(p,
PersistConst.Weights);
flat.BiasActivation = section.ParseDoubleArray(p, BasicNetwork.TagBiasActivation);
}
else if (section.SectionName.Equals("RBF-NETWORK")
&& section.SubSectionName.Equals("ACTIVATION"))
{
int index = 0;
flat.ActivationFunctions = new IActivationFunction[flat.LayerCounts.Length];
foreach (String line in section.Lines)
{
IActivationFunction af;
IList<String> cols = EncogFileSection
.SplitColumns(line);
String name = ReflectionUtil.AfPath
+ cols[0];
try
{
af = (IActivationFunction) ReflectionUtil.LoadObject(name);
}
catch (Exception e)
{
throw new PersistError(e);
}
for (int i = 0; i < af.ParamNames.Length; i++)
{
af.Params[i] = CSVFormat.EgFormat.Parse(cols[i + 1]);
}
flat.ActivationFunctions[index++] = af;
}
}
else if (section.SectionName.Equals("RBF-NETWORK")
&& section.SubSectionName.Equals("RBF"))
{
int index = 0;
int hiddenCount = flat.LayerCounts[1];
int inputCount = flat.LayerCounts[2];
flat.RBF = new IRadialBasisFunction[hiddenCount];
foreach (String line in section.Lines)
{
IRadialBasisFunction rbf;
IList<String> cols = EncogFileSection
.SplitColumns(line);
String name = ReflectionUtil.RBFPath + cols[0];
try
{
rbf = (IRadialBasisFunction) ReflectionUtil.LoadObject(name);
}
catch (TypeLoadException ex)
{
throw new PersistError(ex);
}
catch (TargetException ex)
{
throw new PersistError(ex);
}
catch (MemberAccessException ex)
{
throw new PersistError(ex);
}
rbf.Width = CSVFormat.EgFormat.Parse(cols[1]);
rbf.Peak = CSVFormat.EgFormat.Parse(cols[2]);
rbf.Centers = new double[inputCount];
for (int i = 0; i < inputCount; i++)
{
rbf.Centers[i] = CSVFormat.EgFormat.Parse(cols[i + 3]);
}
flat.RBF[index++] = rbf;
}
}
}
return result;
}
public BasicNetwork CreateNetwork()
{
var network = new BasicNetwork();
network.AddLayer(new BasicLayer(inputs));
network.AddLayer(new BasicLayer(new ActivationLinear(), true, inputs/2 + 1));
network.AddLayer(new BasicLayer(1));
network.Structure.FinalizeStructure();
network.Reset();
/////////////////////////////////
var rbfnetwork = new RBFNetwork(inputs, inputs/2 + 1, 1, RBFEnum.Gaussian);
return network;
}
public object Read(Stream mask0)
{
EncogFileSection section;
IDictionary<string, string> dictionary;
IDictionary<string, string> dictionary2;
int num;
int num2;
int num3;
int num4;
int num5;
int num6;
RBFNetwork network = new RBFNetwork();
FlatNetworkRBF flat = (FlatNetworkRBF) network.Flat;
EncogReadHelper helper = new EncogReadHelper(mask0);
Label_003B:
if ((section = helper.ReadNextSection()) != null)
{
if (!section.SectionName.Equals("RBF-NETWORK"))
{
goto Label_0473;
}
goto Label_069F;
}
if ((((uint) num5) & 0) == 0)
{
goto Label_0236;
}
goto Label_0070;
Label_005E:
if (!section.SectionName.Equals("RBF-NETWORK"))
{
goto Label_003B;
}
Label_0070:
if (section.SubSectionName.Equals("RBF"))
{
num3 = 0;
num4 = flat.LayerCounts[1];
do
{
if (0 != 0)
{
if ((((uint) num6) - ((uint) num2)) < 0)
{
goto Label_0473;
}
goto Label_0416;
}
}
while ((((uint) num3) - ((uint) num3)) > uint.MaxValue);
num5 = flat.LayerCounts[2];
if ((((uint) num4) | 0xfffffffe) == 0)
{
goto Label_0473;
}
goto Label_0273;
}
if ((((uint) num) + ((uint) num)) > uint.MaxValue)
{
goto Label_02F4;
}
if ((((uint) num2) - ((uint) num5)) >= 0)
{
if (((((uint) num4) - ((uint) num3)) > uint.MaxValue) && ((((uint) num5) - ((uint) num5)) < 0))
{
goto Label_005E;
}
goto Label_003B;
}
Label_0236:
if ((((uint) num3) + ((uint) num4)) >= 0)
{
return network;
}
if (4 != 0)
{
goto Label_02F4;
}
if ((((uint) num) + ((uint) num5)) >= 0)
{
goto Label_005E;
}
Label_0273:
flat.RBF = new IRadialBasisFunction[num4];
if (((uint) num2) >= 0)
{
if ((((uint) num5) | 0xfffffffe) == 0)
{
return network;
}
using (IEnumerator<string> enumerator2 = section.Lines.GetEnumerator())
{
string str3;
IRadialBasisFunction function2;
IList<string> list2;
goto Label_00EC;
Label_00D6:
if (num6 < num5)
{
goto Label_00FF;
}
Label_00DC:
flat.RBF[num3++] = function2;
Label_00EC:
if (enumerator2.MoveNext())
{
goto Label_01F2;
}
goto Label_003B;
Label_00FA:
num6 = 0;
goto Label_00D6;
Label_00FF:
function2.Centers[num6] = CSVFormat.EgFormat.Parse(list2[num6 + 3]);
Label_011E:
num6++;
if (0 == 0)
{
goto Label_00D6;
}
goto Label_003B;
Label_012C:
function2.Centers = new double[num5];
goto Label_00FA;
Label_013F:
if (0 != 0)
{
goto Label_011E;
}
list2 = EncogFileSection.SplitColumns(str3);
string name = "Encog.MathUtil.RBF." + list2[0];
try
{
function2 = (IRadialBasisFunction) ReflectionUtil.LoadObject(name);
}
catch (TypeLoadException exception2)
{
throw new PersistError(exception2);
}
catch (TargetException exception3)
{
throw new PersistError(exception3);
}
catch (MemberAccessException exception4)
{
throw new PersistError(exception4);
}
function2.Width = CSVFormat.EgFormat.Parse(list2[1]);
function2.Peak = CSVFormat.EgFormat.Parse(list2[2]);
if ((((uint) num6) + ((uint) num)) >= 0)
{
goto Label_0200;
}
if ((((uint) num4) - ((uint) num3)) < 0)
{
goto Label_00DC;
}
Label_01F2:
str3 = enumerator2.Current;
goto Label_013F;
Label_0200:
if ((((uint) num4) | 3) != 0)
{
goto Label_012C;
}
goto Label_00FA;
}
}
Label_02F4:
using (IEnumerator<string> enumerator = section.Lines.GetEnumerator())
{
string str;
IActivationFunction function;
IList<string> list;
goto Label_0313;
Label_0303:
flat.ActivationFunctions[num++] = function;
Label_0313:
if (enumerator.MoveNext())
{
goto Label_03A2;
}
if (0xff != 0)
{
goto Label_003B;
}
Label_032B:
if (num2 < function.ParamNames.Length)
{
goto Label_0376;
}
goto Label_03AD;
Label_033A:
list = EncogFileSection.SplitColumns(str);
string str2 = "Encog.Engine.Network.Activation." + list[0];
try
{
function = (IActivationFunction) ReflectionUtil.LoadObject(str2);
}
catch (Exception exception)
{
throw new PersistError(exception);
}
num2 = 0;
goto Label_032B;
Label_0376:
function.Params[num2] = CSVFormat.EgFormat.Parse(list[num2 + 1]);
num2++;
goto Label_032B;
Label_03A2:
str = enumerator.Current;
goto Label_033A;
Label_03AD:
if ((((uint) num2) | uint.MaxValue) != 0)
{
goto Label_0303;
}
goto Label_003B;
}
goto Label_005E;
Label_0416:
if (!section.SectionName.Equals("RBF-NETWORK") || !section.SubSectionName.Equals("ACTIVATION"))
{
goto Label_005E;
}
if ((((uint) num2) | 4) == 0)
{
goto Label_069F;
}
num = 0;
Label_045E:
flat.ActivationFunctions = new IActivationFunction[flat.LayerCounts.Length];
goto Label_02F4;
Label_0473:
if (section.SectionName.Equals("RBF-NETWORK"))
{
goto Label_05FF;
}
goto Label_0416;
Label_05EB:
flat.InputCount = EncogFileSection.ParseInt(dictionary2, "inputCount");
flat.LayerCounts = EncogFileSection.ParseIntArray(dictionary2, "layerCounts");
if ((((uint) num) + ((uint) num3)) <= uint.MaxValue)
{
goto Label_06F4;
}
goto Label_06B4;
Label_05FF:
if (!section.SubSectionName.Equals("NETWORK"))
{
goto Label_0416;
}
dictionary2 = section.ParseParams();
flat.BeginTraining = EncogFileSection.ParseInt(dictionary2, "beginTraining");
flat.ConnectionLimit = EncogFileSection.ParseDouble(dictionary2, "connectionLimit");
flat.ContextTargetOffset = EncogFileSection.ParseIntArray(dictionary2, "contextTargetOffset");
flat.ContextTargetSize = EncogFileSection.ParseIntArray(dictionary2, "contextTargetSize");
flat.EndTraining = EncogFileSection.ParseInt(dictionary2, "endTraining");
flat.HasContext = EncogFileSection.ParseBoolean(dictionary2, "hasContext");
goto Label_05EB;
Label_069F:
if (section.SubSectionName.Equals("PARAMS"))
{
dictionary = section.ParseParams();
}
else if (0 == 0)
{
goto Label_06D9;
}
Label_06B4:
EngineArray.PutAll<string, string>(dictionary, network.Properties);
if ((((uint) num5) - ((uint) num5)) >= 0)
{
goto Label_0473;
}
Label_06D9:
if ((((uint) num) - ((uint) num3)) >= 0)
{
if (0 == 0)
{
goto Label_0473;
}
goto Label_05FF;
}
Label_06F4:
if (-2147483648 != 0)
{
flat.LayerFeedCounts = EncogFileSection.ParseIntArray(dictionary2, "layerFeedCounts");
if (((uint) num3) < 0)
{
goto Label_05EB;
}
flat.LayerContextCount = EncogFileSection.ParseIntArray(dictionary2, "layerContextCount");
flat.LayerIndex = EncogFileSection.ParseIntArray(dictionary2, "layerIndex");
if (0 == 0)
{
flat.LayerOutput = EncogFileSection.ParseDoubleArray(dictionary2, "output");
flat.LayerSums = new double[flat.LayerOutput.Length];
flat.OutputCount = EncogFileSection.ParseInt(dictionary2, "outputCount");
}
flat.WeightIndex = EncogFileSection.ParseIntArray(dictionary2, "weightIndex");
if ((((uint) num3) > uint.MaxValue) || ((((uint) num2) - ((uint) num2)) < 0))
{
goto Label_045E;
}
flat.Weights = EncogFileSection.ParseDoubleArray(dictionary2, "weights");
flat.BiasActivation = EncogFileSection.ParseDoubleArray(dictionary2, "biasActivation");
goto Label_003B;
}
return network;
}
public BasicNetwork CreateNetwork()
{
var network = new BasicNetwork();
network.AddLayer(new BasicLayer(WindowSize));
network.AddLayer(new BasicLayer(new ActivationLinear(), true, WindowSize/2 + 1));
network.AddLayer(new BasicLayer(1));
network.Structure.FinalizeStructure();
network.Reset();
var rbfnetwork = new RBFNetwork(WindowSize, WindowSize/2 + 1, 1, RBFEnum.Gaussian);
return network;
}
