GetQ() public abstract method

public abstract GetQ ( int column, int len ) : double[]
column int
len int
return double[]
Esempio n. 1
0
        protected void reconstruct_gradient()
        {
            // reconstruct inactive elements of G from G_bar and free variables

            if (_activeSize == _length)
            {
                return;
            }

            int i, j;
            int nr_free = 0;

            for (j = _activeSize; j < _length; j++)
            {
                _g[j] = _gBar[j] + _p[j];
            }

            for (j = 0; j < _activeSize; j++)
            {
                if (is_free(j))
                {
                    nr_free++;
                }
            }

            if (2 * nr_free < _activeSize)
            {
                Svm.info("\nWARNING: using -h 0 may be faster\n");
            }

            if (nr_free * _length > 2 * _activeSize * (_length - _activeSize))
            {
                for (i = _activeSize; i < _length; i++)
                {
                    double[] Q_i = _q.GetQ(i, _activeSize);
                    for (j = 0; j < _activeSize; j++)
                    {
                        if (is_free(j))
                        {
                            _g[i] += _alpha[j] * Q_i[j];
                        }
                    }
                }
            }
            else
            {
                for (i = 0; i < _activeSize; i++)
                {
                    if (is_free(i))
                    {
                        double[] Q_i     = _q.GetQ(i, _length);
                        double   alpha_i = _alpha[i];
                        for (j = _activeSize; j < _length; j++)
                        {
                            _g[j] += alpha_i * Q_i[j];
                        }
                    }
                }
            }
        }
Esempio n. 2
0
        public virtual void Solve(int length, QMatrix Q, double[] p_, sbyte[] y_,
         double[] alpha_, double Cp, double Cn, double eps, SolutionInfo si, bool shrinking)
        {
            _length = length;
              _q = Q;
              _qd = Q.GetQD();
              _p = (double[]) p_.Clone();
              _y = (sbyte[]) y_.Clone();
              _alpha = (double[]) alpha_.Clone();
              _cp = Cp;
              _cn = Cn;
              _eps = eps;
              _unshrink = false;

              // initialize alpha_status
              _alphaStatus = new BoundType[length];
              for (int i = 0; i < length; i++)
              {
            UpdateAlphaStatus(i);
              }

              // initialize active set (for shrinking)
              _activeSet = new int[length];
              for (int i = 0; i < length; i++)
              {
            _activeSet[i] = i;
              }
              _activeSize = length;

              // initialize gradient
              _g = new double[length];
              _gBar = new double[length];

              for (int i = 0; i < length; i++)
              {
            _g[i] = _p[i];
            _gBar[i] = 0;
              }

              for (int i = 0; i < length; i++)
              {
            if (!IsLowerBound(i))
            {
              double[] Q_i = Q.GetQ(i, length);
              double alpha_i = _alpha[i];

              for (int j = 0; j < length; j++)
              {
            _g[j] += alpha_i * Q_i[j];
              }

              if (IsUpperBound(i))
              {
            for (int j = 0; j < length; j++)
            {
              _gBar[j] += GetC(i) * Q_i[j];
            }
              }
            }
              }

              // optimization step

              int iter = 0;
              int max_iter = Math.Max(10000000, length > int.MaxValue / 100 ? int.MaxValue : 100 * length);
              int counter = Math.Min(length, 1000) + 1;
              int[] working_set = new int[2];

              while (iter < max_iter)
              {
            // show progress and do shrinking

            if (--counter == 0)
            {
              counter = Math.Min(length, 1000);
              if (shrinking) DoShrinking();
              Svm.info(".");
            }

            if (SelectWorkingSet(working_set) != 0)
            {
              // reconstruct the whole gradient
              ReconstructGradient();
              // reset active set size and check
              _activeSize = length;
              Svm.info("*");
              if (SelectWorkingSet(working_set) != 0)
            break;
              else
            counter = 1; // do shrinking next iteration
            }

            int i = working_set[0];
            int j = working_set[1];

            ++iter;

            // update alpha[i] and alpha[j], handle bounds carefully

            double[] Q_i = Q.GetQ(i, _activeSize);
            double[] Q_j = Q.GetQ(j, _activeSize);

            double C_i = GetC(i);
            double C_j = GetC(j);

            double old_alpha_i = _alpha[i];
            double old_alpha_j = _alpha[j];

            if (_y[i] != _y[j])
            {
              double quad_coef = _qd[i] + _qd[j] + 2*Q_i[j];
              if (quad_coef <= 0)
            quad_coef = 1e-12;
              double delta = (-_g[i] - _g[j])/quad_coef;
              double diff = _alpha[i] - _alpha[j];
              _alpha[i] += delta;
              _alpha[j] += delta;

              if (diff > 0)
              {
            if (_alpha[j] < 0)
            {
              _alpha[j] = 0;
              _alpha[i] = diff;
            }
              }
              else
              {
            if (_alpha[i] < 0)
            {
              _alpha[i] = 0;
              _alpha[j] = -diff;
            }
              }
              if (diff > C_i - C_j)
              {
            if (_alpha[i] > C_i)
            {
              _alpha[i] = C_i;
              _alpha[j] = C_i - diff;
            }
              }
              else
              {
            if (_alpha[j] > C_j)
            {
              _alpha[j] = C_j;
              _alpha[i] = C_j + diff;
            }
              }
            }
            else
            {
              double quad_coef = _qd[i] + _qd[j] - 2*Q_i[j];
              if (quad_coef <= 0)
            quad_coef = 1e-12;
              double delta = (_g[i] - _g[j])/quad_coef;
              double sum = _alpha[i] + _alpha[j];
              _alpha[i] -= delta;
              _alpha[j] += delta;

              if (sum > C_i)
              {
            if (_alpha[i] > C_i)
            {
              _alpha[i] = C_i;
              _alpha[j] = sum - C_i;
            }
              }
              else
              {
            if (_alpha[j] < 0)
            {
              _alpha[j] = 0;
              _alpha[i] = sum;
            }
              }
              if (sum > C_j)
              {
            if (_alpha[j] > C_j)
            {
              _alpha[j] = C_j;
              _alpha[i] = sum - C_j;
            }
              }
              else
              {
            if (_alpha[i] < 0)
            {
              _alpha[i] = 0;
              _alpha[j] = sum;
            }
              }
            }

            // update G
            double delta_alpha_i = _alpha[i] - old_alpha_i;
            double delta_alpha_j = _alpha[j] - old_alpha_j;

            for (int k = 0; k < _activeSize; k++)
            {
              _g[k] += Q_i[k]*delta_alpha_i + Q_j[k]*delta_alpha_j;
            }

            // update alpha_status and G_bar
            bool ui = IsUpperBound(i);
            bool uj = IsUpperBound(j);
            UpdateAlphaStatus(i);
            UpdateAlphaStatus(j);
            //int k;
            if (ui != IsUpperBound(i))
            {
              Q_i = Q.GetQ(i, length);
              if (ui)
              {
            for (int k = 0; k < length; k++)
            {
              _gBar[k] -= C_i*Q_i[k];
            }
              }
              else
              {
            for (int k = 0; k < length; k++)
            {
              _gBar[k] += C_i*Q_i[k];
            }
              }
            }

            if (uj != IsUpperBound(j))
            {
              Q_j = Q.GetQ(j, length);
              if (uj)
              {
            for (int k = 0; k < length; k++)
            {
              _gBar[k] -= C_j*Q_j[k];
            }
              }
              else
              {
            for (int k = 0; k < length; k++)
            {
              _gBar[k] += C_j*Q_j[k];
            }
              }
            }
              }

              if (iter >= max_iter)
              {
            if (_activeSize < length)
            {
              // reconstruct the whole gradient to calculate objective value
              ReconstructGradient();
              _activeSize = length;
              Svm.info("*");
            }
            Console.Error.WriteLine("\nWARNING: reaching max number of iterations");
              }

              // calculate rho
              si.Rho = CalculateRho();

              // calculate objective value
              double v = 0;
              for (int i = 0; i < length; i++)
              {
            v += _alpha[i]*(_g[i] + _p[i]);
              }
              si.Obj = v/2;

              // put back the solution
              for (int i = 0; i < length; i++)
              {
            alpha_[_activeSet[i]] = _alpha[i];
              }

              si.UpperBoundP = Cp;
              si.UpperBoundN = Cn;

              Svm.info("\noptimization finished, #iter = " + iter + "\n");
        }
Esempio n. 3
0
        public virtual void Solve(int length, QMatrix Q, double[] p_, sbyte[] y_,
                                  double[] alpha_, double Cp, double Cn, double eps, SolutionInfo si, bool shrinking)
        {
            this._length   = length;
            this._q        = Q;
            _qd            = Q.GetQD();
            _p             = (double[])p_.Clone();
            _y             = (sbyte[])y_.Clone();
            _alpha         = (double[])alpha_.Clone();
            this._cp       = Cp;
            this._cn       = Cn;
            this._eps      = eps;
            this._unshrink = false;

            // initialize alpha_status
            {
                _alphaStatus = new BoundType[length];
                for (int i = 0; i < length; i++)
                {
                    UpdateAlphaStatus(i);
                }
            }

            // initialize active set (for shrinking)
            {
                _activeSet = new int[length];
                for (int i = 0; i < length; i++)
                {
                    _activeSet[i] = i;
                }
                _activeSize = length;
            }

            // initialize gradient
            {
                _g    = new double[length];
                _gBar = new double[length];
                int i;
                for (i = 0; i < length; i++)
                {
                    _g[i]    = _p[i];
                    _gBar[i] = 0;
                }
                for (i = 0; i < length; i++)
                {
                    if (!is_lower_bound(i))
                    {
                        double[] Q_i     = Q.GetQ(i, length);
                        double   alpha_i = _alpha[i];
                        int      j;
                        for (j = 0; j < length; j++)
                        {
                            _g[j] += alpha_i * Q_i[j];
                        }
                        if (is_upper_bound(i))
                        {
                            for (j = 0; j < length; j++)
                            {
                                _gBar[j] += GetC(i) * Q_i[j];
                            }
                        }
                    }
                }
            }

            // optimization step

            int iter     = 0;
            int max_iter = Math.Max(10000000, length > int.MaxValue / 100 ? int.MaxValue : 100 * length);
            int counter  = Math.Min(length, 1000) + 1;

            int[] working_set = new int[2];

            while (iter < max_iter)
            {
                // show progress and do shrinking

                if (--counter == 0)
                {
                    counter = Math.Min(length, 1000);
                    if (shrinking)
                    {
                        do_shrinking();
                    }
                    Svm.info(".");
                }

                if (select_working_set(working_set) != 0)
                {
                    // reconstruct the whole gradient
                    reconstruct_gradient();
                    // reset active set size and check
                    _activeSize = length;
                    Svm.info("*");
                    if (select_working_set(working_set) != 0)
                    {
                        break;
                    }
                    else
                    {
                        counter = 1; // do shrinking next iteration
                    }
                }

                int i = working_set[0];
                int j = working_set[1];

                ++iter;

                // update alpha[i] and alpha[j], handle bounds carefully

                double[] Q_i = Q.GetQ(i, _activeSize);
                double[] Q_j = Q.GetQ(j, _activeSize);

                double C_i = GetC(i);
                double C_j = GetC(j);

                double old_alpha_i = _alpha[i];
                double old_alpha_j = _alpha[j];

                if (_y[i] != _y[j])
                {
                    double quad_coef = _qd[i] + _qd[j] + 2 * Q_i[j];
                    if (quad_coef <= 0)
                    {
                        quad_coef = 1e-12;
                    }
                    double delta = (-_g[i] - _g[j]) / quad_coef;
                    double diff  = _alpha[i] - _alpha[j];
                    _alpha[i] += delta;
                    _alpha[j] += delta;

                    if (diff > 0)
                    {
                        if (_alpha[j] < 0)
                        {
                            _alpha[j] = 0;
                            _alpha[i] = diff;
                        }
                    }
                    else
                    {
                        if (_alpha[i] < 0)
                        {
                            _alpha[i] = 0;
                            _alpha[j] = -diff;
                        }
                    }
                    if (diff > C_i - C_j)
                    {
                        if (_alpha[i] > C_i)
                        {
                            _alpha[i] = C_i;
                            _alpha[j] = C_i - diff;
                        }
                    }
                    else
                    {
                        if (_alpha[j] > C_j)
                        {
                            _alpha[j] = C_j;
                            _alpha[i] = C_j + diff;
                        }
                    }
                }
                else
                {
                    double quad_coef = _qd[i] + _qd[j] - 2 * Q_i[j];
                    if (quad_coef <= 0)
                    {
                        quad_coef = 1e-12;
                    }
                    double delta = (_g[i] - _g[j]) / quad_coef;
                    double sum   = _alpha[i] + _alpha[j];
                    _alpha[i] -= delta;
                    _alpha[j] += delta;

                    if (sum > C_i)
                    {
                        if (_alpha[i] > C_i)
                        {
                            _alpha[i] = C_i;
                            _alpha[j] = sum - C_i;
                        }
                    }
                    else
                    {
                        if (_alpha[j] < 0)
                        {
                            _alpha[j] = 0;
                            _alpha[i] = sum;
                        }
                    }
                    if (sum > C_j)
                    {
                        if (_alpha[j] > C_j)
                        {
                            _alpha[j] = C_j;
                            _alpha[i] = sum - C_j;
                        }
                    }
                    else
                    {
                        if (_alpha[i] < 0)
                        {
                            _alpha[i] = 0;
                            _alpha[j] = sum;
                        }
                    }
                }

                // update G
                double delta_alpha_i = _alpha[i] - old_alpha_i;
                double delta_alpha_j = _alpha[j] - old_alpha_j;

                for (int k = 0; k < _activeSize; k++)
                {
                    _g[k] += Q_i[k] * delta_alpha_i + Q_j[k] * delta_alpha_j;
                }

                // update alpha_status and G_bar
                bool ui = is_upper_bound(i);
                bool uj = is_upper_bound(j);
                UpdateAlphaStatus(i);
                UpdateAlphaStatus(j);
                //int k;
                if (ui != is_upper_bound(i))
                {
                    Q_i = Q.GetQ(i, length);
                    if (ui)
                    {
                        for (int k = 0; k < length; k++)
                        {
                            _gBar[k] -= C_i * Q_i[k];
                        }
                    }
                    else
                    {
                        for (int k = 0; k < length; k++)
                        {
                            _gBar[k] += C_i * Q_i[k];
                        }
                    }
                }

                if (uj != is_upper_bound(j))
                {
                    Q_j = Q.GetQ(j, length);
                    if (uj)
                    {
                        for (int k = 0; k < length; k++)
                        {
                            _gBar[k] -= C_j * Q_j[k];
                        }
                    }
                    else
                    {
                        for (int k = 0; k < length; k++)
                        {
                            _gBar[k] += C_j * Q_j[k];
                        }
                    }
                }
            }

            if (iter >= max_iter)
            {
                if (_activeSize < length)
                {
                    // reconstruct the whole gradient to calculate objective value
                    reconstruct_gradient();
                    _activeSize = length;
                    Svm.info("*");
                }
                Svm.info("\nWARNING: reaching max number of iterations");
            }

            // calculate rho
            si.Rho = calculate_rho();

            // calculate objective value
            double v = 0;

            for (int i = 0; i < length; i++)
            {
                v += _alpha[i] * (_g[i] + _p[i]);
            }
            si.Obj = v / 2;

            // put back the solution
            for (int i = 0; i < length; i++)
            {
                alpha_[_activeSet[i]] = _alpha[i];
            }

            si.UpperBoundP = Cp;
            si.UpperBoundN = Cn;

            Svm.info("\noptimization finished, #iter = " + iter + "\n");
        }