Пример #1
0
        public override double[][][] EstimateXi(IMLDataSet sequence,
                                                ForwardBackwardCalculator fbc, HiddenMarkovModel hmm)
        {
            if (sequence.Count <= 1)
            {
                throw new EncogError(
                          "Must have more than one observation");
            }

            double[][][] xi          = EngineArray.AllocDouble3D((int)sequence.Count - 1, hmm.StateCount, hmm.StateCount);
            double       probability = fbc.Probability();

            for (int t = 0; t < (sequence.Count - 1); t++)
            {
                IMLDataPair o = sequence[t + 1];

                for (int i = 0; i < hmm.StateCount; i++)
                {
                    for (int j = 0; j < hmm.StateCount; j++)
                    {
                        xi[t][i][j] = (fbc.AlphaElement(t, i)
                                       * hmm.TransitionProbability[i][j]
                                       * hmm.StateDistributions[j].Probability(o) * fbc
                                       .BetaElement(t + 1, j)) / probability;
                    }
                }
            }

            return(xi);
        }
Пример #2
0
        /// <summary>
        /// Called internally to advance to the next row.
        /// </summary>
        /// <returns>True if there are more rows to reed.</returns>
        private bool Next()
        {
            // see if any of the CSV readers want to stop
            if (_readCSV.Any(csv => !csv.Next()))
            {
                return(false);
            }

            // see if any of the data sets want to stop
            foreach (var iterator in _readDataSet)
            {
                if (!iterator.MoveNext()) // are we sure that we intended for every other item here? an explanation would be helpful
                {
                    return(false);
                }
                MLDataFieldHolder holder = _dataSetIteratorMap
                                           [iterator];
                IMLDataPair pair = iterator.Current;
                holder.Pair = pair;
            }

            // see if any of the arrays want to stop
            if (_inputFields.OfType <IHasFixedLength>().Any(fl => (_currentIndex + 1) >= fl.Length))
            {
                return(false);
            }

            _currentIndex++;

            return(true);
        }
        /// <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;
        }
Пример #4
0
        /// <summary>
        /// Called internally to obtain the current value for an input field.
        /// </summary>
        /// <param name="field">The input field to determine.</param>
        /// <param name="index">The current index.</param>
        /// <returns>The value for this input field.</returns>
        private void DetermineInputFieldValue(IInputField field, int index)
        {
            double result;

            if (field is InputFieldCSV)
            {
                var     fieldCSV = (InputFieldCSV)field;
                ReadCSV csv      = _csvMap[field];
                result = csv.GetDouble(fieldCSV.Offset);
            }
            else if (field is InputFieldMLDataSet)
            {
                var mlField = (InputFieldMLDataSet)field;
                MLDataFieldHolder holder = _dataSetFieldMap
                                           [field];
                IMLDataPair pair   = holder.Pair;
                int         offset = mlField.Offset;
                if (offset < pair.Input.Count)
                {
                    result = pair.Input[offset];
                }
                else
                {
                    offset -= pair.Input.Count;
                    result  = pair.Ideal[offset];
                }
            }
            else
            {
                result = field.GetValue(index);
            }

            field.CurrentValue = result;
            return;
        }
Пример #5
0
        public void ActivationTemporal()
        {
            var temporal = new TemporalMLDataSet(5, 1);

            temporal.AddDescription(new TemporalDataDescription(new ActivationTANH(), TemporalDataDescription.Type.Raw,
                                                                true, false));
            temporal.AddDescription(new TemporalDataDescription(new ActivationTANH(), TemporalDataDescription.Type.Raw,
                                                                true, false));
            temporal.AddDescription(new TemporalDataDescription(new ActivationTANH(), TemporalDataDescription.Type.Raw,
                                                                false, true));
            for (int i = 0; i < 10; i++)
            {
                TemporalPoint tp = temporal.CreatePoint(i);
                tp[0] = 1.0 + (i * 3);
                tp[1] = 2.0 + (i * 3);
                tp[2] = 3.0 + (i * 3);
            }

            temporal.Generate();

            IEnumerator <IMLDataPair> itr = temporal.GetEnumerator();

            // set 0
            itr.MoveNext();
            IMLDataPair pair = itr.Current;

            Assert.AreEqual(10, pair.Input.Count);
            Assert.AreEqual(1, pair.Ideal.Count);
            Assert.AreEqual(0.75, Math.Round(pair.Input[0] * 4.0) / 4.0);
            Assert.AreEqual(1.0, Math.Round(pair.Input[1] * 4.0) / 4.0);
            Assert.AreEqual(1.0, Math.Round(pair.Input[2] * 4.0) / 4.0);
            Assert.AreEqual(1.0, Math.Round(pair.Input[3] * 4.0) / 4.0);
        }
Пример #6
0
        public static BasicMLDataSet CreateEvaluationSetAndLoad(string @fileName, int startLine, int HowMany, int WindowSize, int outputsize)
        {
            List <double> Opens = QuickCSVUtils.QuickParseCSV(fileName, "Open", startLine, HowMany);
            List <double> High  = QuickCSVUtils.QuickParseCSV(fileName, "High", startLine, HowMany);
            // List<double> Low = QuickCSVUtils.QuickParseCSV(fileName, "Low", startLine, HowMany);
            List <double> Close  = QuickCSVUtils.QuickParseCSV(fileName, "Close", startLine, HowMany);
            List <double> Volume = QuickCSVUtils.QuickParseCSV(fileName, 5, startLine, HowMany);

            double[]           Ranges      = NetworkUtility.CalculateRanges(Opens.ToArray(), Close.ToArray());
            IMLDataPair        aPairInput  = TrainerHelper.ProcessPairs(NetworkUtility.CalculatePercents(Opens.ToArray()), NetworkUtility.CalculatePercents(Opens.ToArray()), WindowSize, outputsize);
            IMLDataPair        aPairInput3 = TrainerHelper.ProcessPairs(NetworkUtility.CalculatePercents(Close.ToArray()), NetworkUtility.CalculatePercents(Close.ToArray()), WindowSize, outputsize);
            IMLDataPair        aPairInput2 = TrainerHelper.ProcessPairs(NetworkUtility.CalculatePercents(High.ToArray()), NetworkUtility.CalculatePercents(High.ToArray()), WindowSize, outputsize);
            IMLDataPair        aPairInput4 = TrainerHelper.ProcessPairs(NetworkUtility.CalculatePercents(Volume.ToArray()), NetworkUtility.CalculatePercents(Volume.ToArray()), WindowSize, outputsize);
            IMLDataPair        aPairInput5 = TrainerHelper.ProcessPairs(NetworkUtility.CalculatePercents(Ranges.ToArray()), NetworkUtility.CalculatePercents(Ranges.ToArray()), WindowSize, outputsize);
            List <IMLDataPair> listData    = new List <IMLDataPair>();

            listData.Add(aPairInput);
            listData.Add(aPairInput2);
            listData.Add(aPairInput3);
            listData.Add(aPairInput4);
            listData.Add((aPairInput5));


            var minitrainning = new BasicMLDataSet(listData);

            return(minitrainning);
        }
Пример #7
0
        /// <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);
        }
Пример #8
0
        /// <summary>
        /// Compute alpha.
        /// </summary>
        /// <param name="hmm">The hidden markov model.</param>
        /// <param name="oseq">The sequence.</param>
        protected void ComputeAlpha(HiddenMarkovModel hmm,
                                    IMLDataSet oseq)
        {
            Alpha = EngineArray.AllocateDouble2D((int)oseq.Count, hmm.StateCount);

            for (int i = 0; i < hmm.StateCount; i++)
            {
                ComputeAlphaInit(hmm, oseq[0], i);
            }

            IEnumerator <IMLDataPair> seqIterator = oseq.GetEnumerator();

            if (seqIterator.MoveNext())
            {
                for (int t = 1; t < oseq.Count; t++)
                {
                    seqIterator.MoveNext(); /////
                    IMLDataPair observation = seqIterator.Current;

                    for (int i = 0; i < hmm.StateCount; i++)
                    {
                        ComputeAlphaStep(hmm, observation, t, i);
                    }
                }
            }
        }
        /// <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);
        }
Пример #10
0
        /// <summary>
        /// Process one training set element.
        /// </summary>
        ///
        /// <param name="input">The network input.</param>
        /// <param name="ideal">The ideal values.</param>
        /// <param name="s">The significance of this error.</param>
        private void Process(IMLDataPair pair)
        {
            _network.Compute(pair.Input, _actual);

            _errorCalculation.UpdateError(_actual, pair.Ideal, pair.Significance);

            // Calculate error for the output layer.
            _ef.CalculateError(
                _network.ActivationFunctions[0], _layerSums, _layerOutput,
                pair.Ideal, _actual, _layerDelta, _flatSpot[0],
                pair.Significance);

            // Apply regularization, if requested.
            if (_owner.L1 > EncogFramework.DefaultDoubleEqual ||
                _owner.L1 > EncogFramework.DefaultDoubleEqual)
            {
                double[] lp = new double[2];
                CalculateRegularizationPenalty(lp);
                for (int i = 0; i < _actual.Length; i++)
                {
                    double p = (lp[0] * _owner.L1) + (lp[1] * _owner.L2);
                    _layerDelta[i] += p;
                }
            }

            // Propagate backwards (chain rule from calculus).
            for (int i = _network.BeginTraining; i < _network
                 .EndTraining; i++)
            {
                ProcessLevel(i);
            }
        }
        /// <summary>
        /// Construct the LMA object.
        /// </summary>
        /// <param name="network">The network to train. Must have a single output neuron.</param>
        /// <param name="training">The training data to use. Must be indexable.</param>
        /// <param name="h">The Hessian calculator to use.</param>
        public LevenbergMarquardtTraining(BasicNetwork network,
                                          IMLDataSet training, IComputeHessian h)
            : base(TrainingImplementationType.Iterative)
        {
            ValidateNetwork.ValidateMethodToData(network, training);

            Training           = training;
            _indexableTraining = Training;
            this._network      = network;
            _trainingLength    = (int)_indexableTraining.Count;
            _weightCount       = this._network.Structure.CalculateSize();
            _lambda            = 0.1;
            _deltas            = new double[_weightCount];
            _diagonal          = new double[_weightCount];

            var input = new BasicMLData(
                _indexableTraining.InputSize);
            var ideal = new BasicMLData(
                _indexableTraining.IdealSize);

            _pair = new BasicMLDataPair(input, ideal);

            _hessian = h;
            _hessian.Init(network, training);
        }
Пример #12
0
        /// <summary>
        /// Construct the LMA object.
        /// </summary>
        ///
        /// <param name="network">The network to train. Must have a single output neuron.</param>
        /// <param name="training">The training data to use. Must be indexable.</param>
        public LevenbergMarquardtTraining(BasicNetwork network,
                                          IMLDataSet training) : base(TrainingImplementationType.Iterative)
        {
            ValidateNetwork.ValidateMethodToData(network, training);
            if (network.OutputCount != 1)
            {
                throw new TrainingError(
                          "Levenberg Marquardt requires an output layer with a single neuron.");
            }

            Training           = training;
            _indexableTraining = Training;
            _network           = network;
            _trainingLength    = (int)_indexableTraining.Count;
            _parametersLength  = _network.Structure.CalculateSize();
            _hessianMatrix     = new Matrix(_parametersLength,
                                            _parametersLength);
            _hessian  = _hessianMatrix.Data;
            _alpha    = 0.0d;
            _beta     = 1.0d;
            _lambda   = 0.1d;
            _deltas   = new double[_parametersLength];
            _gradient = new double[_parametersLength];
            _diagonal = new double[_parametersLength];

            var input = new BasicMLData(
                _indexableTraining.InputSize);
            var ideal = new BasicMLData(
                _indexableTraining.IdealSize);

            _pair = new BasicMLDataPair(input, ideal);
        }
Пример #13
0
 public JacobianChainRule(BasicNetwork network, IMLDataSet indexableTraining)
 {
     BasicMLData data;
     BasicMLData data2;
     if (0 == 0)
     {
         goto Label_0055;
     }
     Label_0009:
     this._x61830ac74d65acc3 = new BasicMLDataPair(data, data2);
     return;
     Label_0055:
     this._xb12276308f0fa6d9 = indexableTraining;
     if (0 == 0)
     {
     }
     this._x87a7fc6a72741c2e = network;
     this._xabb126b401219ba2 = network.Structure.CalculateSize();
     this._x530ae94d583e0ea1 = (int) this._xb12276308f0fa6d9.Count;
     this._xbdeab667c25bbc32 = EngineArray.AllocateDouble2D(this._x530ae94d583e0ea1, this._xabb126b401219ba2);
     this._xc8a462f994253347 = new double[this._x530ae94d583e0ea1];
     data = new BasicMLData(this._xb12276308f0fa6d9.InputSize);
     data2 = new BasicMLData(this._xb12276308f0fa6d9.IdealSize);
     if (-2147483648 != 0)
     {
         goto Label_0009;
     }
     goto Label_0055;
 }
        /// <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);
        }
Пример #15
0
        /// <summary>
        /// Process one training set element.
        /// </summary>
        /// <param name="outputNeuron">The output neuron.</param>
        private void Process(int outputNeuron, IMLDataPair pair)
        {
            _flat.Compute(pair.Input, _actual);

            double e = pair.Ideal[outputNeuron] - _actual[outputNeuron];

            _error += e * e;

            for (int i = 0; i < _actual.Length; i++)
            {
                if (i == outputNeuron)
                {
                    _layerDelta[i] = _flat.ActivationFunctions[0]
                                     .DerivativeFunction(_layerSums[i],
                                                         _layerOutput[i]);
                }
                else
                {
                    _layerDelta[i] = 0;
                }
            }

            for (int i = _flat.BeginTraining; i < _flat.EndTraining; i++)
            {
                ProcessLevel(i);
            }

            // calculate gradients
            for (int j = 0; j < _weights.Length; j++)
            {
                _gradients[j] += e * _derivative[j];
                _totDeriv[j]  += _derivative[j];
            }
        }
Пример #16
0
        public void Run(int index)
        {
            IMLDataPair pair = _training[index];

            Process(pair);
            _owner.Report(_gradients, 0, null);
            EngineArray.Fill(_gradients, 0);
        }
Пример #17
0
        /// <summary>
        /// Add input and expected output. This is used for supervised training.
        /// </summary>
        /// <param name="inputData">The input data to train on.</param>
        public override void Add(IMLDataPair inputData)
        {
            if (!(inputData.Input is ImageMLData))
            {
                throw new NeuralNetworkError(MUST_USE_IMAGE);
            }

            base.Add(inputData);
        }
Пример #18
0
        /// <summary>
        /// Called to load training data for a company.  This is how the training data is actually created.
        /// To prepare input data for recognition use the CreateData method.  The training set will be
        /// added to.  This allows the network to learn from multiple companies if this method is called
        /// multiple times.
        /// </summary>
        /// <param name="symbol">The ticker symbol.</param>
        /// <param name="training">The training set to add to.</param>
        /// <param name="from">Beginning date</param>
        /// <param name="to">Ending date</param>
        public void LoadCompany(String symbol, BasicMLDataSet training, DateTime from, DateTime to)
        {
            IMarketLoader          loader     = new YahooFinanceLoader();
            var                    ticker     = new TickerSymbol(symbol);
            IList <MarketDataType> dataNeeded = new List <MarketDataType>();

            dataNeeded.Add(MarketDataType.AdjustedClose);
            dataNeeded.Add(MarketDataType.Close);
            dataNeeded.Add(MarketDataType.Open);
            dataNeeded.Add(MarketDataType.High);
            dataNeeded.Add(MarketDataType.Low);
            var results = (List <LoadedMarketData>)loader.Load(ticker, dataNeeded, from, to);

            results.Sort();

            for (var index = PredictWindow; index < results.Count - EvalWindow; index++)
            {
                var data = results[index];

                // determine bull or bear position, or neither
                var bullish = false;
                var bearish = false;

                for (int search = 1; search <= EvalWindow; search++)
                {
                    var data2        = results[index + search];
                    var priceBase    = data.GetData(MarketDataType.AdjustedClose);
                    var priceCompare = data2.GetData(MarketDataType.AdjustedClose);
                    var diff         = priceCompare - priceBase;
                    var percent      = diff / priceBase;
                    if (percent > BullPercent)
                    {
                        bullish = true;
                    }
                    else if (percent < BearPercent)
                    {
                        bearish = true;
                    }
                }

                IMLDataPair pair = null;

                if (bullish)
                {
                    pair = CreateData(results, index, true);
                }
                else if (bearish)
                {
                    pair = CreateData(results, index, false);
                }

                if (pair != null)
                {
                    training.Add(pair);
                }
            }
        }
Пример #19
0
        /// <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>
        /// Read an individual record.
        /// </summary>
        /// <param name="index">The zero-based index. Specify 0 for the first record, 1 for
        /// the second, and so on.</param>
        /// <param name="pair">The data to read.</param>
        public void GetRecord(long index, IMLDataPair pair)
        {
            double[] inputTarget = pair.InputArray;
            double[] idealTarget = pair.IdealArray;

            egb.SetLocation((int)index);
            egb.Read(inputTarget);
            egb.Read(idealTarget);
            pair.Significance = egb.Read();
        }
        /// <summary>
        /// Add a data pair of both input and ideal data.
        /// </summary>
        /// <param name="pair">The pair to add.</param>
        public void Add(IMLDataPair pair)
        {
            if (!loading)
            {
                throw new IMLDataError(ERROR_ADD);
            }

            egb.Write(pair.Input.Data);
            egb.Write(pair.Ideal.Data);
            egb.Write(pair.Significance);
        }
Пример #22
0
        /// <summary>
        /// Add a data pair of both input and ideal data.
        /// </summary>
        /// <param name="pair">The pair to add.</param>
        public void Add(IMLDataPair pair)
        {
            if (!_loading)
            {
                throw new IMLDataError(ErrorAdd);
            }

            _egb.Write(pair.Input);
            _egb.Write(pair.Ideal);
            _egb.Write(pair.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;
        }
Пример #24
0
        /// <summary>
        /// Compute the alpha step.
        /// </summary>
        /// <param name="hmm">The hidden markov model.</param>
        /// <param name="o">The sequence element.</param>
        /// <param name="t">The alpha step.</param>
        /// <param name="j">The column.</param>
        protected void ComputeAlphaStep(HiddenMarkovModel hmm,
                                        IMLDataPair o, int t, int j)
        {
            double sum = 0.0;

            for (int i = 0; i < hmm.StateCount; i++)
            {
                sum += Alpha[t - 1][i] * hmm.TransitionProbability[i][j];
            }

            Alpha[t][j] = sum * hmm.StateDistributions[j].Probability(o);
        }
        /// <summary>
        ///     The SSE error with the current weights.
        /// </summary>
        /// <returns></returns>
        private double CalculateError()
        {
            var result = new ErrorCalculation();

            for (int i = 0; i < _trainingLength; i++)
            {
                _pair = _indexableTraining[i];
                IMLData actual = _network.Compute(_pair.Input);
                result.UpdateError(actual, _pair.Ideal, _pair.Significance);
            }

            return(result.CalculateSSE());
        }
Пример #26
0
        /// <summary>
        /// Compute the beta step.
        /// </summary>
        /// <param name="hmm">The hidden markov model.</param>
        /// <param name="o">THe data par to compute.</param>
        /// <param name="t">THe matrix row.</param>
        /// <param name="i">THe matrix column.</param>
        protected void ComputeBetaStep(HiddenMarkovModel hmm,
                                       IMLDataPair o, int t, int i)
        {
            double sum = 0.0;

            for (int j = 0; j < hmm.StateCount; j++)
            {
                sum += Beta[t + 1][j] * hmm.TransitionProbability[i][j]
                       * hmm.StateDistributions[j].Probability(o);
            }

            Beta[t][i] = sum;
        }
Пример #27
0
        /// <summary>
        /// Makes a random dataset with the number of IMLDatapairs.
        /// Quite useful to test networks (benchmarks).
        /// </summary>
        /// <param name="inputs">The inputs.</param>
        /// <param name="predictWindow">The predict window.</param>
        /// <param name="numberofPairs">The numberof pairs.</param>
        /// <returns></returns>
        public static BasicMLDataSet MakeRandomIMLDataset(int inputs, int predictWindow, int numberofPairs)
        {
            BasicMLDataSet SuperSet = new BasicMLDataSet();

            for (int i = 0; i < numberofPairs; i++)
            {
                double[]    firstinput  = MakeInputs(inputs);
                double[]    secondideal = MakeInputs(inputs);
                IMLDataPair pair        = ProcessPairs(firstinput, secondideal, inputs, predictWindow);
                SuperSet.Add(pair);
            }
            return(SuperSet);
        }
Пример #28
0
 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;
 }
Пример #29
0
        public ViterbiCalculator(IMLDataSet oseq, HiddenMarkovModel hmm)
        {
            if (oseq.Count < 1)
            {
                throw new EncogError("Must not have empty sequence");
            }

            this.delta          = EngineArray.AllocateDouble2D((int)oseq.Count, hmm.StateCount);
            this.psy            = EngineArray.AllocateInt2D((int)oseq.Count, hmm.StateCount);
            this._stateSequence = new int[oseq.Count];

            for (int i = 0; i < hmm.StateCount; i++)
            {
                this.delta[0][i] = -Math.Log(hmm.GetPi(i))
                                   - Math.Log(hmm.StateDistributions[i].Probability(
                                                  oseq[0]));
                this.psy[0][i] = 0;
            }

            int t = 1;

            for (int index = 1; index < oseq.Count; index++)
            {
                IMLDataPair observation = oseq[index];

                for (int i = 0; i < hmm.StateCount; i++)
                {
                    ComputeStep(hmm, observation, t, i);
                }

                t++;
            }

            this.lnProbability = Double.PositiveInfinity;
            for (int i = 0; i < hmm.StateCount; i++)
            {
                double thisProbability = this.delta[oseq.Count - 1][i];

                if (this.lnProbability > thisProbability)
                {
                    this.lnProbability             = thisProbability;
                    _stateSequence[oseq.Count - 1] = i;
                }
            }
            this.lnProbability = -this.lnProbability;

            for (int t2 = (int)(oseq.Count - 2); t2 >= 0; t2--)
            {
                _stateSequence[t2] = this.psy[t2 + 1][_stateSequence[t2 + 1]];
            }
        }
        /// <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);
        }
Пример #31
0
        /// <inheritdoc/>
        public double Probability(IMLDataPair o)
        {
            // double[] v = o.InputArray;
            //  Matrix vmm = Matrix.CreateColumnMatrix(EngineArray.Subtract(v,
            Matrix vmm = Matrix.CreateColumnMatrix(EngineArray.Subtract(o.Input,
                                                                        _mean));
            Matrix t      = MatrixMath.Multiply(_covarianceInv, vmm);
            double expArg = MatrixMath.Multiply(MatrixMath.Transpose(vmm), t)
                            [0, 0] * -0.5;

            return(Math.Exp(expArg)
                   / (Math.Pow(2.0 * Math.PI, _dimension / 2.0) * Math.Pow(
                          _covarianceDet, 0.5)));
        }
        /// <summary>
        /// Determine the probability of the specified data pair.
        /// </summary>
        /// <param name="o">THe data pair.</param>
        /// <returns>The probability.</returns>
        public double Probability(IMLDataPair o)
        {
            double result = 1;

            for (int i = 0; i < _probabilities.Length; i++)
            {
                if (o.Input[i] > (_probabilities[i].Length - 1))
                {
                    throw new EncogError("Wrong observation value");
                }
                result *= _probabilities[i][(int)o.Input[i]];
            }

            return(result);
        }
Пример #33
0
 public LevenbergMarquardtTraining(BasicNetwork network, IMLDataSet training)
     : base(TrainingImplementationType.Iterative)
 {
     if (2 != 0)
     {
         ValidateNetwork.ValidateMethodToData(network, training);
         if (network.OutputCount != 1)
         {
             throw new TrainingError("Levenberg Marquardt requires an output layer with a single neuron.");
         }
         this.Training = training;
         goto Label_0134;
     }
     Label_00A8:
     this._xdadd8f92d75a3aba = new double[this._xe2982b936ae423cd];
     this._x878c4eb3cef19a5a = new double[this._xe2982b936ae423cd];
     this._x3cb63876dda4b74a = new double[this._xe2982b936ae423cd];
     if (0xff == 0)
     {
         return;
     }
     BasicMLData input = new BasicMLData(this._xb12276308f0fa6d9.InputSize);
     BasicMLData ideal = new BasicMLData(this._xb12276308f0fa6d9.IdealSize);
     this._x61830ac74d65acc3 = new BasicMLDataPair(input, ideal);
     if (-1 != 0)
     {
         return;
     }
     Label_0134:
     this._xb12276308f0fa6d9 = this.Training;
     this._x87a7fc6a72741c2e = network;
     this._x8557b7ee760663f3 = (int) this._xb12276308f0fa6d9.Count;
     this._xe2982b936ae423cd = this._x87a7fc6a72741c2e.Structure.CalculateSize();
     this._x05fb16197e552de6 = new Matrix(this._xe2982b936ae423cd, this._xe2982b936ae423cd);
     this._xc410e3804222557a = this._x05fb16197e552de6.Data;
     this._x6ad505c7ef981b0e = 0.0;
     this._xd7d571ecee49d1e4 = 1.0;
     this._x3271cefb1a159639 = 0.1;
     goto Label_00A8;
 }
Пример #34
0
 public void Add(IMLDataPair inputData)
 {
     throw new TrainingError("Direct adds to the folded dataset are not supported.");
 }
 /// <inheritdoc/>
 public double Probability(IMLDataPair o)
 {
     // double[] v = o.InputArray;
       //  Matrix vmm = Matrix.CreateColumnMatrix(EngineArray.Subtract(v,
     Matrix vmm = Matrix.CreateColumnMatrix(EngineArray.Subtract(o.Input,
                                                                 _mean));
     Matrix t = MatrixMath.Multiply(_covarianceInv, vmm);
     double expArg = MatrixMath.Multiply(MatrixMath.Transpose(vmm), t)
                         [0, 0]*-0.5;
     return Math.Exp(expArg)
            /(Math.Pow(2.0*Math.PI, _dimension/2.0)*Math.Pow(
                _covarianceDet, 0.5));
 }
Пример #36
0
 /// <summary>
 /// Get a record.
 /// </summary>
 /// <param name="index">The index.</param>
 /// <param name="pair">The record.</param>
 public void GetRecord(int index, IMLDataPair pair)
 {
     _underlying.GetRecord(CurrentFoldOffset + index, pair);
 }
Пример #37
0
        /// <summary>
        /// Add input and expected output. This is used for supervised training.
        /// </summary>
        /// <param name="inputData">The input data to train on.</param>
        public override void Add(IMLDataPair inputData)
        {
            if (!(inputData.Input is ImageMLData))
            {
                throw new NeuralNetworkError(MUST_USE_IMAGE);
            }

            base.Add(inputData);
        }
 /// <summary>
 /// Adding directly is not supported. Rather, add temporal points and
 /// generate the training data.
 /// </summary>
 /// <param name="inputData">Not used.</param>
 public override sealed void Add(IMLDataPair inputData)
 {
     throw new TemporalError(AddNotSupported);
 }
Пример #39
0
 /// <summary>
 /// Get the cluster for the specified data pair. 
 /// </summary>
 /// <param name="o">The data pair to use..</param>
 /// <returns>The cluster the pair is in.</returns>
 public int Cluster(IMLDataPair o)
 {
     return _clustersHash[o];
 }
        /// <summary>
        /// Determine the probability of the specified data pair. 
        /// </summary>
        /// <param name="o">THe data pair.</param>
        /// <returns>The probability.</returns>
        public double Probability(IMLDataPair o)
        {
            double result = 1;

            for (int i = 0; i < _probabilities.Length; i++)
            {
                if (o.Input[i] > (_probabilities[i].Length - 1))
                {
                    throw new EncogError("Wrong observation value");
                }
                result *= _probabilities[i][(int) o.Input[i]];
            }

            return result;
        }
Пример #41
0
 /// <summary>
 /// Put an object into the specified cluster. 
 /// </summary>
 /// <param name="o">The object.</param>
 /// <param name="n">The cluster number.</param>
 public void Put(IMLDataPair o, int n)
 {
     _clustersHash[o] = n;
     _clusters[n].Add(o);
 }
 public IMLDataPair RestoreDataVector(IMLDataPair vectorTorestore)
 {
     return this._x9a9fa564793616f5.RestoreDataVector(vectorTorestore);
 }
 public IMLDataPair ProcessDataVector(IMLDataPair vectorToProcess)
 {
     return this._x9a9fa564793616f5.ProcessDataVector(vectorToProcess);
 }
        /// <summary>
        ///     The SSE error with the current weights.
        /// </summary>
        /// <returns></returns>
        private double CalculateError()
        {
            var result = new ErrorCalculation();

            for (int i = 0; i < _trainingLength; i++)
            {
                _pair = _indexableTraining[i];
                IMLData actual = _network.Compute(_pair.Input);
                result.UpdateError(actual, _pair.Ideal, _pair.Significance);
            }

            return result.CalculateSSE();
        }
        /// <summary>
        ///     Construct the LMA object.
        /// </summary>
        /// <param name="network">The network to train. Must have a single output neuron.</param>
        /// <param name="training"></param>
        /// <param name="h">The training data to use. Must be indexable.</param>
        public LevenbergMarquardtTraining(BasicNetwork network,
            IMLDataSet training, IComputeHessian h)
            : base(TrainingImplementationType.Iterative)
        {
            ValidateNetwork.ValidateMethodToData(network, training);

            Training = training;
            _indexableTraining = Training;
            this._network = network;
            _trainingLength = _indexableTraining.Count;
            _weightCount = this._network.Structure.CalculateSize();
            _lambda = 0.1;
            _deltas = new double[_weightCount];
            _diagonal = new double[_weightCount];

            var input = new BasicMLData(
                _indexableTraining.InputSize);
            var ideal = new BasicMLData(
                _indexableTraining.IdealSize);
            _pair = new BasicMLDataPair(input, ideal);

            _hessian = h;
        }
Пример #46
0
        /// <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,
                                 TrainFlatNetworkProp 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);
        }
Пример #47
0
 /// <summary>
 /// Remove an object from the specified cluster. 
 /// </summary>
 /// <param name="o">The object to remove.</param>
 /// <param name="n">The cluster to remove from.</param>
 public void Remove(IMLDataPair o, int n)
 {
     _clustersHash[o] = -1;
     _clusters[n].Remove(o);
 }
        private void ComputeStep(HiddenMarkovModel hmm, IMLDataPair o,
                int t, int j)
        {
            double minDelta = Double.PositiveInfinity;
            int min_psy = 0;

            for (int i = 0; i < hmm.StateCount; i++)
            {
                double thisDelta = this.delta[t - 1][i]
                        - Math.Log(hmm.TransitionProbability[i][j]);

                if (minDelta > thisDelta)
                {
                    minDelta = thisDelta;
                    min_psy = i;
                }
            }

            this.delta[t][j] = minDelta
                    - Math.Log(hmm.StateDistributions[j].Probability(o));
            this.psy[t][j] = min_psy;
        }
 /// <summary>
 /// Obtain the next pair.
 /// </summary>
 public void ObtainPair()
 {
     _iterator.MoveNext();
     _pair = _iterator.Current;
 }
Пример #50
0
 private double xddf5c75e1d743e26(IMLDataPair x61830ac74d65acc3)
 {
     double num2;
     int num3;
     int num4;
     int layerTotalNeuronCount;
     int layerNeuronCount;
     double layerOutput;
     int num8;
     int num10;
     double num12;
     int num13;
     int num14;
     int num15;
     int num17;
     double num = 0.0;
     if ((((uint) num17) + ((uint) num8)) >= 0)
     {
         goto Label_030C;
     }
     goto Label_0039;
     Label_0030:
     if (num10 < layerNeuronCount)
     {
         IActivationFunction activation;
         double num11;
         layerOutput = this._x87a7fc6a72741c2e.GetLayerOutput(num4, num10);
         do
         {
             activation = this._x87a7fc6a72741c2e.GetActivation(num4);
             num11 = this._x87a7fc6a72741c2e.GetWeight(num4, num10, 0);
         }
         while ((((uint) num10) | uint.MaxValue) == 0);
         num12 = (xd3eb00c1c38e3a49(activation, layerOutput) * xbc17cb206c45d25e(activation, num2)) * num11;
         if (((uint) num) >= 0)
         {
             goto Label_0106;
         }
         goto Label_00B3;
     }
     Label_0039:
     if (num3 > 0)
     {
         num3--;
         num4--;
         if ((((uint) layerOutput) - ((uint) layerNeuronCount)) <= uint.MaxValue)
         {
             layerTotalNeuronCount = this._x87a7fc6a72741c2e.GetLayerTotalNeuronCount(num3);
             layerNeuronCount = this._x87a7fc6a72741c2e.GetLayerNeuronCount(num4);
             if ((((uint) num8) + ((uint) layerTotalNeuronCount)) > uint.MaxValue)
             {
                 goto Label_0095;
             }
             if (2 == 0)
             {
                 goto Label_0115;
             }
             if ((((uint) num3) + ((uint) layerNeuronCount)) < 0)
             {
                 goto Label_0352;
             }
             num10 = 0;
         }
         goto Label_0030;
     }
     if ((((uint) num12) - ((uint) num17)) >= 0)
     {
         if ((((uint) num15) & 0) == 0)
         {
             return num;
         }
         goto Label_0039;
     }
     goto Label_00B3;
     Label_005D:
     if (num14 < layerNeuronCount)
     {
         goto Label_00B3;
     }
     this._xbdeab667c25bbc32[this._x4c51ad74d6bcc9e9][this._x82d75873c9eb7116++] = num12 * this._x87a7fc6a72741c2e.GetLayerOutput(num3, num13);
     Label_0095:
     num13++;
     Label_009B:
     if (num13 < layerTotalNeuronCount)
     {
         num2 = 0.0;
         goto Label_0115;
     }
     if (((uint) num10) <= uint.MaxValue)
     {
         num10++;
         goto Label_0030;
     }
     Label_00B3:
     num15 = 0;
     while (num15 < layerTotalNeuronCount)
     {
         num2 += this._x87a7fc6a72741c2e.GetWeight(num3, num15, num14) * layerOutput;
     Label_00CE:
         num15++;
     }
     num14++;
     goto Label_005D;
     Label_0106:
     num13 = 0;
     goto Label_009B;
     Label_0115:
     num14 = 0;
     goto Label_005D;
     Label_030C:
     num2 = 0.0;
     this._x87a7fc6a72741c2e.Compute(x61830ac74d65acc3.Input);
     num3 = this._x87a7fc6a72741c2e.LayerCount - 2;
     num4 = this._x87a7fc6a72741c2e.LayerCount - 1;
     layerTotalNeuronCount = this._x87a7fc6a72741c2e.GetLayerTotalNeuronCount(num3);
     Label_0352:
     layerNeuronCount = this._x87a7fc6a72741c2e.GetLayerNeuronCount(num4);
     layerOutput = this._x87a7fc6a72741c2e.Structure.Flat.LayerOutput[0];
     num = x61830ac74d65acc3.Ideal[0] - layerOutput;
     num8 = 0;
     while (true)
     {
         while (num8 >= layerTotalNeuronCount)
         {
             if (((uint) layerOutput) > uint.MaxValue)
             {
                 goto Label_00CE;
             }
             if ((((uint) num2) + ((uint) num10)) >= 0)
             {
                 goto Label_0039;
             }
             if ((((uint) num14) & 0) == 0)
             {
                 goto Label_030C;
             }
         }
         double num9 = this._x87a7fc6a72741c2e.GetLayerOutput(num3, num8);
         if (((uint) layerOutput) > uint.MaxValue)
         {
             goto Label_0106;
         }
         this._xbdeab667c25bbc32[this._x4c51ad74d6bcc9e9][this._x82d75873c9eb7116++] = xd3eb00c1c38e3a49(this._x87a7fc6a72741c2e.GetActivation(num4), layerOutput) * num9;
         num8++;
     }
 }
Пример #51
0
 /// <summary>
 /// Determine if the specified object is in one of the clusters. 
 /// </summary>
 /// <param name="o">The object to check.</param>
 /// <param name="x">The cluster.</param>
 /// <returns>True if the object is in the cluster.</returns>
 public bool IsInCluster(IMLDataPair o, int x)
 {
     return Cluster(o) == x;
 }
Пример #52
0
        /// <summary>
        /// Add a data pair of both input and ideal data. 
        /// </summary>
        /// <param name="pair">The pair to add.</param>
        public void Add(IMLDataPair pair)
        {
            if (!_loading)
            {
                throw new IMLDataError(ErrorAdd);
            }

            _egb.Write(pair.Input);
            _egb.Write(pair.Ideal);
            _egb.Write(pair.Significance);
        }
        /// <summary>
        /// Construct the LMA object.
        /// </summary>
        ///
        /// <param name="network">The network to train. Must have a single output neuron.</param>
        /// <param name="training">The training data to use. Must be indexable.</param>
        public LevenbergMarquardtTraining(BasicNetwork network,
                                          IMLDataSet training) : base(TrainingImplementationType.Iterative)
        {
            ValidateNetwork.ValidateMethodToData(network, training);
            if (network.OutputCount != 1)
            {
                throw new TrainingError(
                    "Levenberg Marquardt requires an output layer with a single neuron.");
            }

            Training = training;
            _indexableTraining = Training;
            _network = network;
            _trainingLength = (int) _indexableTraining.Count;
            _parametersLength = _network.Structure.CalculateSize();
            _hessianMatrix = new Matrix(_parametersLength,
                                       _parametersLength);
            _hessian = _hessianMatrix.Data;
            _alpha = 0.0d;
            _beta = 1.0d;
            _lambda = 0.1d;
            _deltas = new double[_parametersLength];
            _gradient = new double[_parametersLength];
            _diagonal = new double[_parametersLength];

            var input = new BasicMLData(
                _indexableTraining.InputSize);
            var ideal = new BasicMLData(
                _indexableTraining.IdealSize);
            _pair = new BasicMLDataPair(input, ideal);
        }
Пример #54
0
 public IMLDataPair RestoreDataVector(IMLDataPair vectorToProcess)
 {
     return this.xd3764d4f1e921081.RestoreDataVector(vectorToProcess);
 }
Пример #55
0
 /// <summary>
 /// Not supported.
 /// </summary>
 /// <param name="inputData">Not used.</param>
 public void Add(IMLDataPair inputData)
 {
     throw new TrainingError(AddNotSupported);
 }
Пример #56
0
 public void GetRecord(long index, IMLDataPair pair)
 {
     this._x51176d6d4e8e34fa.GetRecord(this.CurrentFoldOffset + index, pair);
 }
Пример #57
0
 public IMLDataPair ProcessDataVector(IMLDataPair vectorToProcess)
 {
     return new BasicMLDataPair(this.ProcessInputVector(vectorToProcess.Input), this.ProcessIdealVector(vectorToProcess.Ideal));
 }
Пример #58
0
 public IMLDataPair RestoreDataVector(IMLDataPair vectorToProcess)
 {
     return vectorToProcess;
 }
        /// <summary>
        /// Process one training set element.
        /// </summary>
        /// <param name="outputNeuron">The output neuron.</param>
        /// <param name="derivative">The derivatives.</param>
        /// <param name="pair">The training pair.</param>
        private void Process(int outputNeuron, double[] derivative, IMLDataPair pair)
        {
            _flat.Compute(pair.Input, _actual);

            double e = pair.Ideal[outputNeuron] - _actual[outputNeuron];
            _error += e*e;

            for (int i = 0; i < _actual.Length; i++)
            {
                if (i == outputNeuron)
                {
                    _layerDelta[i] = _flat.ActivationFunctions[0]
                        .DerivativeFunction(_layerSums[i],
                                            _layerOutput[i]);
                }
                else
                {
                    _layerDelta[i] = 0;
                }
            }

            for (int i = _flat.BeginTraining; i < _flat.EndTraining; i++)
            {
                ProcessLevel(i, derivative);
            }

            // calculate gradients
            for (int j = 0; j < _weights.Length; j++)
            {
                _gradients[j] += e*derivative[j];
                _totDeriv[j] += derivative[j];
            }

            // update hessian
            for (int i = 0; i < _weightCount; i++)
            {
                for (int j = 0; j < _weightCount; j++)
                {
                    _hessian[i][j] += derivative[i] * derivative[j];
                }
            }
        }
Пример #60
0
 public IMLDataPair RestoreDataVector(IMLDataPair vectorToProcess)
 {
     return new BasicMLDataPair(this.RestoreInputVector(vectorToProcess.Input), this.RestoreIdealVector(vectorToProcess.Ideal));
 }