Solve() public method

Solve A*X = B
public Solve ( System.Matrix B ) : System.Matrix
B System.Matrix A Matrix with as many rows as A and any number of columns.
return System.Matrix
Ejemplo n.º 1
0
 public override void Iteration()
 {
     LUDecomposition decomposition = null;
     double num;
     double num2;
     double num3;
     double num4;
     int num5;
     int num6;
     IMLData data;
     double num7;
     double num8;
     if ((((uint) num4) | 15) != 0)
     {
         goto Label_0399;
     }
     goto Label_01C7;
     Label_0022:
     base.PostIteration();
     if ((((uint) num5) & 0) == 0)
     {
         return;
     }
     goto Label_01C7;
     Label_0044:
     this._xd7d571ecee49d1e4 = Math.Abs((double) ((this._x8557b7ee760663f3 - this._xc7c4e9c099884228) / (2.0 * num)));
     Label_0073:
     this.Error = num;
     goto Label_0022;
     Label_00F1:
     if ((num4 >= num3) && (this._x3271cefb1a159639 < 1E+25))
     {
         this._x3271cefb1a159639 *= 10.0;
         num5 = 0;
     Label_01EF:
         if (num5 < this._xe2982b936ae423cd)
         {
             this._xc410e3804222557a[num5][num5] = this._x3cb63876dda4b74a[num5] + (this._x3271cefb1a159639 + this._x6ad505c7ef981b0e);
             num5++;
             if ((((uint) num7) + ((uint) num3)) >= 0)
             {
                 goto Label_01EF;
             }
         }
         else
         {
             if ((((uint) num7) + ((uint) num8)) > uint.MaxValue)
             {
                 return;
             }
             decomposition = new LUDecomposition(this._x05fb16197e552de6);
             if (!decomposition.IsNonsingular)
             {
                 goto Label_00F1;
             }
             this._xdadd8f92d75a3aba = decomposition.Solve(this._x878c4eb3cef19a5a);
         }
         if (((uint) num6) >= 0)
         {
             if (0 != 0)
             {
                 goto Label_0340;
             }
             goto Label_01C7;
         }
         goto Label_029A;
     }
     this._x3271cefb1a159639 /= 10.0;
     if (this._x6c57e14b737e51f6 && (decomposition != null))
     {
         num8 = Trace(decomposition.Inverse());
         this._xc7c4e9c099884228 = this._xe2982b936ae423cd - (this._x6ad505c7ef981b0e * num8);
         if (((uint) num7) < 0)
         {
             goto Label_0044;
         }
         this._x6ad505c7ef981b0e = ((double) this._xe2982b936ae423cd) / ((2.0 * num2) + num8);
         if ((((uint) num4) | 0xfffffffe) != 0)
         {
             goto Label_0044;
         }
         goto Label_0022;
     }
     goto Label_0073;
     Label_0137:
     num7 = this._x61830ac74d65acc3.Ideal[0] - data[0];
     num += num7 * num7;
     num6++;
     Label_0161:
     if (num6 < this._x8557b7ee760663f3)
     {
         this._xb12276308f0fa6d9.GetRecord((long) num6, this._x61830ac74d65acc3);
         data = this._x87a7fc6a72741c2e.Compute(this._x61830ac74d65acc3.Input);
         goto Label_0137;
     }
     num /= 2.0;
     num4 = (this._xd7d571ecee49d1e4 * num) + (this._x6ad505c7ef981b0e * num2);
     goto Label_00F1;
     Label_01C7:
     num2 = this.UpdateWeights();
     num = 0.0;
     num6 = 0;
     goto Label_0161;
     Label_029A:
     if ((((uint) num7) | 0xff) == 0)
     {
         goto Label_0137;
     }
     this._x3271cefb1a159639 /= 10.0;
     goto Label_00F1;
     Label_0340:
     num4 = num3 + 1.0;
     if ((((uint) num4) - ((uint) num6)) >= 0)
     {
         goto Label_029A;
     }
     Label_0399:
     base.PreIteration();
     this._x2f33d779e5a20b28 = NetworkCODEC.NetworkToArray(this._x87a7fc6a72741c2e);
     if ((((uint) num8) | 4) == 0)
     {
         goto Label_0022;
     }
     IComputeJacobian jacobian = new JacobianChainRule(this._x87a7fc6a72741c2e, this._xb12276308f0fa6d9);
     num = jacobian.Calculate(this._x2f33d779e5a20b28);
     num2 = this.x01818299df58497e();
     this.CalculateHessian(jacobian.Jacobian, jacobian.RowErrors);
     num3 = (this._xd7d571ecee49d1e4 * num) + (this._x6ad505c7ef981b0e * num2);
     goto Label_0340;
 }
        /// <inheritdoc />
        public override void Iteration()
        {
            if (!_initComplete)
            {
                _hessian.Init(_network, Training);
                _initComplete = true;
            }

            PreIteration();

            _hessian.Clear();
            _weights = NetworkCODEC.NetworkToArray(_network);

            _hessian.Compute();
            double currentError = _hessian.SSE;
            SaveDiagonal();

            double startingError = currentError;
            bool done = false;
            bool singular;

            while (!done)
            {
                ApplyLambda();
                var decomposition = new LUDecomposition(_hessian.HessianMatrix);

                singular = decomposition.IsNonsingular;

                if (singular)
                {
                    _deltas = decomposition.Solve(_hessian.Gradients);
                    UpdateWeights();
                    currentError = CalculateError();
                }

                if (!singular || currentError >= startingError)
                {
                    _lambda *= ScaleLambda;
                    if (_lambda > LambdaMax)
                    {
                        _lambda = LambdaMax;
                        done = true;
                    }
                }
                else
                {
                    _lambda /= ScaleLambda;
                    done = true;
                }
            }

            Error = currentError;

            PostIteration();
        }
        /// <summary>
        /// Perform one iteration.
        /// </summary>
        ///
        public override void Iteration()
        {
            LUDecomposition decomposition = null;

            PreIteration();

            _weights = NetworkCODEC.NetworkToArray(_network);

            IComputeJacobian j = new JacobianChainRule(_network,
                                                      _indexableTraining);

            double sumOfSquaredErrors = j.Calculate(_weights);
            double sumOfSquaredWeights = CalculateSumOfSquaredWeights();

            // this.setError(j.getError());
            CalculateHessian(j.Jacobian, j.RowErrors);

            // Define the objective function
            // bayesian regularization objective function
            double objective = _beta*sumOfSquaredErrors + _alpha
                               *sumOfSquaredWeights;
            double current = objective + 1.0d;

            // Start the main Levenberg-Macquardt method
            _lambda /= ScaleLambda;

            // We'll try to find a direction with less error
            // (or where the objective function is smaller)
            while ((current >= objective)
                   && (_lambda < LambdaMax))
            {
                _lambda *= ScaleLambda;

                // Update diagonal (Levenberg-Marquardt formula)
                for (int i = 0; i < _parametersLength; i++)
                {
                    _hessian[i][i] = _diagonal[i]
                                    + (_lambda + _alpha);
                }

                // Decompose to solve the linear system
                decomposition = new LUDecomposition(_hessianMatrix);

                // Check if the Jacobian has become non-invertible
                if (!decomposition.IsNonsingular)
                {
                    continue;
                }

                // Solve using LU (or SVD) decomposition
                _deltas = decomposition.Solve(_gradient);

                // Update weights using the calculated deltas
                sumOfSquaredWeights = UpdateWeights();

                // Calculate the new error
                sumOfSquaredErrors = 0.0d;
                for (int i = 0; i < _trainingLength; i++)
                {
                    _indexableTraining.GetRecord(i, _pair);
                    IMLData actual = _network
                        .Compute(_pair.Input);
                    double e = _pair.Ideal[0]
                               - actual[0];
                    sumOfSquaredErrors += e*e;
                }
                sumOfSquaredErrors /= 2.0d;

                // Update the objective function
                current = _beta*sumOfSquaredErrors + _alpha
                          *sumOfSquaredWeights;

                // If the object function is bigger than before, the method
                // is tried again using a greater dumping factor.
            }

            // If this iteration caused a error drop, then next iteration
            // will use a smaller damping factor.
            _lambda /= ScaleLambda;

            if (_useBayesianRegularization && (decomposition != null))
            {
                // Compute the trace for the inverse Hessian
                double trace = Trace(decomposition.Inverse());

                // Poland update's formula:
                _gamma = _parametersLength - (_alpha*trace);
                _alpha = _parametersLength
                        /(2.0d*sumOfSquaredWeights + trace);
                _beta = Math.Abs((_trainingLength - _gamma)
                                /(2.0d*sumOfSquaredErrors));
            }

            Error = sumOfSquaredErrors;

            PostIteration();
        }
        /// <summary>
        /// Perform one iteration.
        /// </summary>
        public override void Iteration()
        {
            LUDecomposition decomposition;
            PreIteration();

            _hessian.Clear();
            _weights = NetworkCODEC.NetworkToArray(_network);

            _hessian.Compute();
            double currentError = _hessian.SSE;
            SaveDiagonal();

            double startingError = currentError;
            bool done = false;

            while (!done)
            {
                ApplyLambda();
                decomposition = new LUDecomposition(_hessian.HessianMatrix);

                if (decomposition.IsNonsingular)
                {
                    _deltas = decomposition.Solve(_hessian.Gradients);

                    UpdateWeights();
                    currentError = CalculateError();

                    if (currentError < startingError)
                    {
                        _lambda /= LevenbergMarquardtTraining.ScaleLambda;
                        done = true;
                    }
                }

                if (!done)
                {
                    _lambda *= LevenbergMarquardtTraining.ScaleLambda;
                    if (_lambda > LevenbergMarquardtTraining.LambdaMax)
                    {
                        _lambda = LevenbergMarquardtTraining.LambdaMax;
                        done = true;
                    }
                }
            }

            Error = currentError;

            PostIteration();
        }