/// <summary> /// Clone into the flat network passed in. /// </summary> /// /// <param name="result">The network to copy into.</param> public void CloneFlatNetwork(FlatNetwork result) { result._inputCount = _inputCount; result._layerCounts = EngineArray.ArrayCopy(_layerCounts); result._layerIndex = EngineArray.ArrayCopy(_layerIndex); result._layerOutput = EngineArray.ArrayCopy(_layerOutput); result._layerSums = EngineArray.ArrayCopy(_layerSums); result._layerFeedCounts = EngineArray.ArrayCopy(_layerFeedCounts); result._contextTargetOffset = EngineArray .ArrayCopy(_contextTargetOffset); result._contextTargetSize = EngineArray .ArrayCopy(_contextTargetSize); result._layerContextCount = EngineArray .ArrayCopy(_layerContextCount); result._biasActivation = EngineArray.ArrayCopy(_biasActivation); result._outputCount = _outputCount; result._weightIndex = _weightIndex; result._weights = _weights; result._activationFunctions = new IActivationFunction[_activationFunctions.Length]; for (int i = 0; i < result._activationFunctions.Length; i++) { result._activationFunctions[i] = (IActivationFunction)_activationFunctions[i].Clone(); } result._beginTraining = _beginTraining; result._endTraining = _endTraining; }
/// <summary> /// Clone the network. /// </summary> /// /// <returns>A clone of the network.</returns> public virtual Object Clone() { var result = new FlatNetwork(); CloneFlatNetwork(result); return(result); }
public TrainFlatNetworkBackPropagation(FlatNetwork network, IMLDataSet training, double theLearningRate, double theMomentum) : base(network, training) { this._xef52c16be8e501c9 = theMomentum; this._x9b481c22b6706459 = theLearningRate; this._xe4def4d471bbc130 = new double[network.Weights.Length]; }
/// <summary> /// Program entry point. /// </summary> /// <param name="app">Holds arguments and other info.</param> public void Execute(IExampleInterface app) { var network = new FlatNetwork(2, 4, 0, 1, false); network.Randomize(); IMLDataSet trainingSet = new BasicMLDataSet(XORInput, XORIdeal); var train = new TrainFlatNetworkResilient(network, trainingSet); int epoch = 1; do { train.Iteration(); Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error); epoch++; } while (train.Error > 0.01); var output = new double[1]; // test the neural network Console.WriteLine(@"Neural Network Results:"); foreach (IMLDataPair pair in trainingSet) { double[] input = pair.Input.Data; network.Compute(input, output); Console.WriteLine(input[0] + @"," + input[1] + @":" + output[0]); } }
public TrainFlatNetworkQPROP(FlatNetwork network, IMLDataSet training, double theLearningRate) : base(network, training) { this.LearningRate = theLearningRate; this.LastDelta = new double[base.Network.Weights.Length]; this.Decay = 0.0001; this.OutputEpsilon = 0.35; }
public TrainFlatNetworkSCG(FlatNetwork network, IMLDataSet training) : base(network, training) { int num; if ((((uint) num) - ((uint) num)) <= uint.MaxValue) { this._xd938fd32778a1c95 = true; if (((uint) num) < 0) { goto Label_0069; } goto Label_0134; } if ((((uint) num) & 0) == 0) { goto Label_00BD; } goto Label_0094; Label_0069: this._xb55b340ae3a3e4e0 = new double[num]; this._x268cb8b20222b0dc = true; if ((((uint) num) + ((uint) num)) <= uint.MaxValue) { if (((uint) num) >= 0) { return; } goto Label_00BD; } Label_0094: num = this._x2f33d779e5a20b28.Length; this._xb9f048818eee629c = new double[num]; this._x9af996963d03fd21 = new double[num]; if (((uint) num) > uint.MaxValue) { goto Label_0134; } this._x9c79b5ad7b769b12 = new double[num]; goto Label_0069; Label_00BD: this._x31add3b0010a0a52 = 0.0; this._x3271cefb1a159639 = 1E-06; this._xd4d57078d70c1d3d = 0.0; this._x20753e64c7ee4faf = 0.0; this._xac19ed778412b7a3 = false; this._x2f33d779e5a20b28 = EngineArray.ArrayCopy(network.Weights); goto Label_0094; Label_0134: this._xd938fd32778a1c95 = true; this._xf7845a6fecd5afc3 = 0.0; if ((((uint) num) + ((uint) num)) > uint.MaxValue) { return; } goto Label_00BD; }
/// <inheritdoc/> public virtual void Init(BasicNetwork theNetwork, IMLDataSet theTraining) { int weightCount = theNetwork.Structure.Flat.Weights.Length; _flat = theNetwork.Flat; _training = theTraining; _network = theNetwork; _gradients = new double[weightCount]; _hessianMatrix = new Matrix(weightCount, weightCount); _hessian = _hessianMatrix.Data; }
/// <inheritdoc/> public virtual void Init(BasicNetwork theNetwork, IMLDataSet theTraining) { int weightCount = theNetwork.Structure.Flat.Weights.Length; flat = theNetwork.Flat; training = theTraining; network = theNetwork; gradients = new double[weightCount]; hessianMatrix = new Matrix(weightCount, weightCount); hessian = hessianMatrix.Data; derivative = new double[weightCount]; }
public static void Evaluate(FlatNetwork network, IMLDataSet trainingSet) { double[] output = new double[1]; foreach (IMLDataPair pair in trainingSet) { network.Compute(pair.Input.Data, output); Console.WriteLine(pair.Input.Data[0] + @"," + pair.Input[1] + @", actual=" + output[0] + @",ideal=" + pair.Ideal[0]); } }
/// <summary> /// Construct a cross validation trainer. /// </summary> /// /// <param name="train">The training</param> /// <param name="k">The number of folds.</param> public CrossValidationKFold(IMLTrain train, int k) : base(train.Method, (FoldedDataSet) train.Training) { _train = train; Folded.Fold(k); _flatNetwork = ((BasicNetwork) train.Method).Structure.Flat; _networks = new NetworkFold[k]; for (int i = 0; i < _networks.Length; i++) { _networks[i] = new NetworkFold(_flatNetwork); } }
public GradientWorker(FlatNetwork theNetwork, TrainFlatNetworkProp theOwner, IMLDataSet theTraining, int theLow, int theHigh, double[] theFlatSpots, IErrorFunction ef) { goto Label_0155; Label_0114: this._x071bde1041617fce = theOwner; this._x0ba854627e1326f9 = theFlatSpots; this._x58c3d5da5c5c72db = new double[this._x87a7fc6a72741c2e.LayerOutput.Length]; this._xe05127febf8b7904 = new double[this._x87a7fc6a72741c2e.Weights.Length]; this._xd505507cf33ae543 = new double[this._x87a7fc6a72741c2e.OutputCount]; if (0 == 0) { this._x2f33d779e5a20b28 = this._x87a7fc6a72741c2e.Weights; if ((((uint) theHigh) + ((uint) theLow)) <= uint.MaxValue) { this._xb25095f37f20a1c1 = this._x87a7fc6a72741c2e.LayerIndex; if (((uint) theLow) <= uint.MaxValue) { this._xe05f7b8f952f0ba4 = this._x87a7fc6a72741c2e.LayerCounts; this._x7d5bf19d36074a85 = this._x87a7fc6a72741c2e.WeightIndex; this._x5e72e5e601f79c78 = this._x87a7fc6a72741c2e.LayerOutput; this._x59e01312f2f4aa96 = this._x87a7fc6a72741c2e.LayerSums; this._xc99b49dd213196ca = this._x87a7fc6a72741c2e.LayerFeedCounts; this._x2cb049236d33bbda = ef; } } } this._x61830ac74d65acc3 = BasicMLDataPair.CreatePair(this._x87a7fc6a72741c2e.InputCount, this._x87a7fc6a72741c2e.OutputCount); if (0 == 0) { return; } Label_0155: this._x84e81691256999b2 = new ErrorCalculation(); this._x87a7fc6a72741c2e = theNetwork; this._x823a2b9c8bf459c5 = theTraining; if (0xff == 0) { return; } do { if ((((uint) theHigh) + ((uint) theLow)) > uint.MaxValue) { goto Label_0114; } this._xd12d1dba8a023d95 = theLow; } while (0 != 0); this._x628ea9b89457a2a9 = theHigh; goto Label_0114; }
public TrainFlatNetworkResilient(FlatNetwork network, IMLDataSet training, double zeroTolerance, double initialUpdate, double maxStep) : base(network, training) { if ((((uint) initialUpdate) + ((uint) initialUpdate)) <= uint.MaxValue) { this._x3cb1c2ba1a55e11e = new double[network.Weights.Length]; this._x04273e480202ea1d = zeroTolerance; this._xc63f21bb42b68cf5 = maxStep; if ((((uint) zeroTolerance) + ((uint) initialUpdate)) >= 0) { this._xa3001a0faa4f9279 = new double[base.Network.Weights.Length]; this._xe4def4d471bbc130 = new double[base.Network.Weights.Length]; } } for (int i = 0; i < this._x3cb1c2ba1a55e11e.Length; i++) { this._x3cb1c2ba1a55e11e[i] = initialUpdate; } }
protected TrainFlatNetworkProp(FlatNetwork network, IMLDataSet training) { Label_0036: this._x823a2b9c8bf459c5 = training; if (0x7fffffff != 0) { this._x87a7fc6a72741c2e = network; this.Gradients = new double[this._x87a7fc6a72741c2e.Weights.Length]; } this._x135f4ca6b0437cfc = new double[this._x87a7fc6a72741c2e.Weights.Length]; if (4 != 0) { this._x9d091b0a73271a88 = training; this._xc2715388adc0d1f8 = 0; this._xb8f73f2bca8b57ea = null; this.FixFlatSpot = true; this.ErrorFunction = new LinearErrorFunction(); if (0xff == 0) { goto Label_0036; } } }
public CrossValidationKFold(IMLTrain train, int k) : base(train.Method, (FoldedDataSet) train.Training) { int num; if ((((uint) k) | 1) != 0) { this._xd87f6a9c53c2ed9f = train; base.Folded.Fold(k); goto Label_0083; } if (0xff != 0) { goto Label_0083; } Label_0039: num = 0; while (num < this._x5f6ed0047d99f4b6.Length) { this._x5f6ed0047d99f4b6[num] = new NetworkFold(this._xef94864849922d07); if (((uint) k) >= 0) { } num++; } if (((uint) num) <= uint.MaxValue) { return; } Label_0083: this._xef94864849922d07 = ((BasicNetwork) train.Method).Structure.Flat; this._x5f6ed0047d99f4b6 = new NetworkFold[k]; if (8 == 0) { return; } goto Label_0039; }
/// <summary> /// Construct a fold from the specified flat network. /// </summary> /// /// <param name="flat">THe flat network.</param> public NetworkFold(FlatNetwork flat) { _weights = EngineArray.ArrayCopy(flat.Weights); _output = EngineArray.ArrayCopy(flat.LayerOutput); }
/// <summary> /// Copy weights and output to the network. /// </summary> /// /// <param name="target">The network to copy to.</param> public void CopyToNetwork(FlatNetwork target) { EngineArray.ArrayCopy(_weights, target.Weights); EngineArray.ArrayCopy(_output, target.LayerOutput); }
/// <summary> /// Create an array of activations based on a flat network. /// </summary> /// <param name="flat">The flat network.</param> /// <returns></returns> public int[] CreateActivations(FlatNetwork flat) { var result = new int[flat.ActivationFunctions.Length]; for (int i = 0; i < flat.ActivationFunctions.Length; i++) { IActivationFunction af = flat.ActivationFunctions[i]; if (af is ActivationLinear) { result[i] = 0; } else if (af is ActivationTANH) { result[i] = 1; } if (af is ActivationSigmoid) { result[i] = 2; } if (af is ActivationElliottSymmetric) { result[i] = 3; } if (af is ActivationElliott) { result[i] = 4; } } return result; }
/// <summary> /// Create an array of doubles to hold the specified flat network. /// </summary> /// <param name="flat">The flat network to use as a model.</param> /// <returns>The new array.</returns> public double[] CreateParams(FlatNetwork flat) { var result = new double[flat.ActivationFunctions.Length]; EngineArray.Fill(result, 1); return result; }
/// <summary> /// Construct a propagation object. /// </summary> /// /// <param name="network">The network.</param> /// <param name="training">The training set.</param> protected Propagation(IContainsFlat network, IMLDataSet training) : base(TrainingImplementationType.Iterative) { _network = network; _flat = network.Flat; _training = training; Gradients = new double[_flat.Weights.Length]; _lastGradient = new double[_flat.Weights.Length]; _indexable = training; _numThreads = 0; _reportedException = null; FixFlatSpot = true; ErrorFunction = new LinearErrorFunction(); }
public void FinalizeStructure() { FlatLayer[] layerArray; int num; BasicLayer layer; if (this._layers.Count >= 2) { goto Label_00D4; } throw new NeuralNetworkError("There must be at least two layers before the structure is finalized."); Label_001A: if (num < this._layers.Count) { goto Label_009A; } this._flat = new FlatNetwork(layerArray); this.FinalizeLimit(); Label_003D: this._layers.Clear(); this.EnforceLimit(); return; Label_0062: layerArray[num] = layer; num++; goto Label_001A; Label_006F: if (2 != 0) { goto Label_0062; } Label_0088: while (layer.Activation == null) { layer.Activation = new ActivationLinear(); if (0 == 0) { goto Label_006F; } } if (((uint) num) > uint.MaxValue) { goto Label_006F; } goto Label_0062; Label_009A: layer = (BasicLayer) this._layers[num]; goto Label_0088; if ((((uint) num) - ((uint) num)) < 0) { goto Label_003D; } Label_00D4: layerArray = new FlatLayer[this._layers.Count]; num = 0; if (((uint) num) < 0) { goto Label_009A; } if (0 != 0) { goto Label_006F; } goto Label_001A; }
/// <summary> /// Clone into the flat network passed in. /// </summary> /// /// <param name="result">The network to copy into.</param> public void CloneFlatNetwork(FlatNetwork result) { result._inputCount = _inputCount; result._layerCounts = EngineArray.ArrayCopy(_layerCounts); result._layerIndex = EngineArray.ArrayCopy(_layerIndex); result._layerOutput = EngineArray.ArrayCopy(_layerOutput); result._layerSums = EngineArray.ArrayCopy(_layerSums); result._layerFeedCounts = EngineArray.ArrayCopy(_layerFeedCounts); result._contextTargetOffset = EngineArray .ArrayCopy(_contextTargetOffset); result._contextTargetSize = EngineArray .ArrayCopy(_contextTargetSize); result._layerContextCount = EngineArray .ArrayCopy(_layerContextCount); result._biasActivation = EngineArray.ArrayCopy(_biasActivation); result._outputCount = _outputCount; result._weightIndex = _weightIndex; result._weights = _weights; result._activationFunctions = new IActivationFunction[_activationFunctions.Length]; for (int i = 0; i < result._activationFunctions.Length; i++) { result._activationFunctions[i] = (IActivationFunction) _activationFunctions[i].Clone(); } result._beginTraining = _beginTraining; result._endTraining = _endTraining; }
/// <summary> /// Build the synapse and layer structure. This method should be called after /// you are done adding layers to a network, or change the network's logic /// property. /// </summary> /// public void FinalizeStructure() { if (_layers.Count < 2) { throw new NeuralNetworkError( "There must be at least two layers before the structure is finalized."); } var flatLayers = new FlatLayer[_layers.Count]; for (int i = 0; i < _layers.Count; i++) { var layer = (BasicLayer) _layers[i]; if (layer.Activation == null) { layer.Activation = new ActivationLinear(); } flatLayers[i] = layer; } _flat = new FlatNetwork(flatLayers); FinalizeLimit(); _layers.Clear(); EnforceLimit(); }
private void CheckWithModel(FlatNetwork model, FlatNetwork pruned) { Assert.AreEqual(model.Weights.Length, pruned.Weights.Length); Assert.AreEqual(model.ContextTargetOffset, pruned.ContextTargetOffset); Assert.AreEqual(model.ContextTargetSize, pruned.ContextTargetSize); Assert.AreEqual(model.LayerCounts, pruned.LayerCounts); Assert.AreEqual(model.LayerFeedCounts, pruned.LayerFeedCounts); Assert.AreEqual(model.LayerIndex, pruned.LayerIndex); Assert.AreEqual(model.LayerOutput.Length, pruned.LayerOutput.Length); Assert.AreEqual(model.WeightIndex, pruned.WeightIndex); }
public static long BenchmarkEncogFlat(double[][] input, double[][] output) { var network = new FlatNetwork(input[0].Length, HIDDEN_COUNT, 0, output[0].Length, false); network.Randomize(); var trainingSet = new BasicMLDataSet(input, output); var train = new TrainFlatNetworkBackPropagation( network, trainingSet, 0.7, 0.7); var a = new double[2]; var b = new double[1]; var sw = new Stopwatch(); sw.Start(); // run epoch of learning procedure for (int i = 0; i < ITERATIONS; i++) { train.Iteration(); } sw.Stop(); return sw.ElapsedMilliseconds; }
public void CloneFlatNetwork(FlatNetwork result) { int num; result._inputCount = this._inputCount; goto Label_0172; Label_001F: if (num < result._activationFunctions.Length) { result._activationFunctions[num] = (IActivationFunction) this._activationFunctions[num].Clone(); if ((((uint) num) & 0) == 0) { if (-2 == 0) { goto Label_0133; } num++; goto Label_001F; } if ((((uint) num) | 4) != 0) { goto Label_0172; } goto Label_0122; } result._beginTraining = this._beginTraining; result._endTraining = this._endTraining; return; Label_00BF: result._weights = this._weights; result._activationFunctions = new IActivationFunction[this._activationFunctions.Length]; num = 0; goto Label_001F; Label_0122: result._layerIndex = EngineArray.ArrayCopy(this._layerIndex); Label_0133: result._layerOutput = EngineArray.ArrayCopy(this._layerOutput); result._layerSums = EngineArray.ArrayCopy(this._layerSums); result._layerFeedCounts = EngineArray.ArrayCopy(this._layerFeedCounts); result._contextTargetOffset = EngineArray.ArrayCopy(this._contextTargetOffset); result._contextTargetSize = EngineArray.ArrayCopy(this._contextTargetSize); result._layerContextCount = EngineArray.ArrayCopy(this._layerContextCount); result._biasActivation = EngineArray.ArrayCopy(this._biasActivation); result._outputCount = this._outputCount; result._weightIndex = this._weightIndex; if (3 == 0) { goto Label_001F; } goto Label_00BF; Label_0172: result._layerCounts = EngineArray.ArrayCopy(this._layerCounts); if ((((uint) num) - ((uint) num)) > uint.MaxValue) { goto Label_00BF; } goto Label_0122; }
/// <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; }
/// <summary> /// Copy the weights and output from the network. /// </summary> /// /// <param name="source">The network to copy from.</param> public void CopyFromNetwork(FlatNetwork source) { EngineArray.ArrayCopy(source.Weights, _weights); EngineArray.ArrayCopy(source.LayerOutput, _output); }
/// <summary> /// Read an object. /// </summary> /// public Object Read(Stream mask0) { var result = new BasicNetwork(); var flat = new FlatNetwork(); var ins0 = new EncogReadHelper(mask0); EncogFileSection section; while ((section = ins0.ReadNextSection()) != null) { if (section.SectionName.Equals("BASIC") && section.SubSectionName.Equals("PARAMS")) { IDictionary<String, String> paras = section.ParseParams(); EngineArray.PutAll(paras, result.Properties); } if (section.SectionName.Equals("BASIC") && 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("BASIC") && 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 (TypeLoadException e) { throw new PersistError(e); } catch (TargetException e) { throw new PersistError(e); } catch (MemberAccessException 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; } } } result.Structure.Flat = flat; return result; }
public virtual object Clone() { FlatNetwork result = new FlatNetwork(); this.CloneFlatNetwork(result); return result; }
/// <summary> /// Clone the network. /// </summary> /// /// <returns>A clone of the network.</returns> public virtual Object Clone() { var result = new FlatNetwork(); CloneFlatNetwork(result); return result; }
/// <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) { _weightCount = theNetwork.Weights.Length; _hessian = EngineArray.AllocateDouble2D(_weightCount,_weightCount); _training = theTraining; _flat = theNetwork; _layerDelta = new double[_flat.LayerOutput.Length]; _actual = new double[_flat.OutputCount]; _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; }
/// <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); }