Package org.opencv.ml

Class SVM


  • public class SVM
    extends StatModel
    Support Vector Machines. SEE: REF: ml_intro_svm
    • Constructor Detail

      • SVM

        protected SVM​(long addr)
    • Method Detail

      • __fromPtr__

        public static SVM __fromPtr__​(long addr)
      • getType

        public int getType()
        SEE: setType
        Returns:
        automatically generated
      • setType

        public void setType​(int val)
        getType SEE: getType
        Parameters:
        val - automatically generated
      • getGamma

        public double getGamma()
        SEE: setGamma
        Returns:
        automatically generated
      • setGamma

        public void setGamma​(double val)
        getGamma SEE: getGamma
        Parameters:
        val - automatically generated
      • getCoef0

        public double getCoef0()
        SEE: setCoef0
        Returns:
        automatically generated
      • setCoef0

        public void setCoef0​(double val)
        getCoef0 SEE: getCoef0
        Parameters:
        val - automatically generated
      • getDegree

        public double getDegree()
        SEE: setDegree
        Returns:
        automatically generated
      • setDegree

        public void setDegree​(double val)
        getDegree SEE: getDegree
        Parameters:
        val - automatically generated
      • getC

        public double getC()
        SEE: setC
        Returns:
        automatically generated
      • setC

        public void setC​(double val)
        getC SEE: getC
        Parameters:
        val - automatically generated
      • getNu

        public double getNu()
        SEE: setNu
        Returns:
        automatically generated
      • setNu

        public void setNu​(double val)
        getNu SEE: getNu
        Parameters:
        val - automatically generated
      • getP

        public double getP()
        SEE: setP
        Returns:
        automatically generated
      • setP

        public void setP​(double val)
        getP SEE: getP
        Parameters:
        val - automatically generated
      • getClassWeights

        public Mat getClassWeights()
        SEE: setClassWeights
        Returns:
        automatically generated
      • setClassWeights

        public void setClassWeights​(Mat val)
        getClassWeights SEE: getClassWeights
        Parameters:
        val - automatically generated
      • getTermCriteria

        public TermCriteria getTermCriteria()
        SEE: setTermCriteria
        Returns:
        automatically generated
      • setTermCriteria

        public void setTermCriteria​(TermCriteria val)
        getTermCriteria SEE: getTermCriteria
        Parameters:
        val - automatically generated
      • getKernelType

        public int getKernelType()
        Type of a %SVM kernel. See SVM::KernelTypes. Default value is SVM::RBF.
        Returns:
        automatically generated
      • setKernel

        public void setKernel​(int kernelType)
        Initialize with one of predefined kernels. See SVM::KernelTypes.
        Parameters:
        kernelType - automatically generated
      • trainAuto

        public boolean trainAuto​(Mat samples,
                                 int layout,
                                 Mat responses,
                                 int kFold,
                                 ParamGrid Cgrid,
                                 ParamGrid gammaGrid,
                                 ParamGrid pGrid,
                                 ParamGrid nuGrid,
                                 ParamGrid coeffGrid,
                                 ParamGrid degreeGrid,
                                 boolean balanced)
        Trains an %SVM with optimal parameters
        Parameters:
        samples - training samples
        layout - See ml::SampleTypes.
        responses - vector of responses associated with the training samples.
        kFold - Cross-validation parameter. The training set is divided into kFold subsets. One subset is used to test the model, the others form the train set. So, the %SVM algorithm is
        Cgrid - grid for C
        gammaGrid - grid for gamma
        pGrid - grid for p
        nuGrid - grid for nu
        coeffGrid - grid for coeff
        degreeGrid - grid for degree
        balanced - If true and the problem is 2-class classification then the method creates more balanced cross-validation subsets that is proportions between classes in subsets are close to such proportion in the whole train dataset. The method trains the %SVM model automatically by choosing the optimal parameters C, gamma, p, nu, coef0, degree. Parameters are considered optimal when the cross-validation estimate of the test set error is minimal. This function only makes use of SVM::getDefaultGrid for parameter optimization and thus only offers rudimentary parameter options. This function works for the classification (SVM::C_SVC or SVM::NU_SVC) as well as for the regression (SVM::EPS_SVR or SVM::NU_SVR). If it is SVM::ONE_CLASS, no optimization is made and the usual %SVM with parameters specified in params is executed.
        Returns:
        automatically generated
      • trainAuto

        public boolean trainAuto​(Mat samples,
                                 int layout,
                                 Mat responses,
                                 int kFold,
                                 ParamGrid Cgrid,
                                 ParamGrid gammaGrid,
                                 ParamGrid pGrid,
                                 ParamGrid nuGrid,
                                 ParamGrid coeffGrid,
                                 ParamGrid degreeGrid)
        Trains an %SVM with optimal parameters
        Parameters:
        samples - training samples
        layout - See ml::SampleTypes.
        responses - vector of responses associated with the training samples.
        kFold - Cross-validation parameter. The training set is divided into kFold subsets. One subset is used to test the model, the others form the train set. So, the %SVM algorithm is
        Cgrid - grid for C
        gammaGrid - grid for gamma
        pGrid - grid for p
        nuGrid - grid for nu
        coeffGrid - grid for coeff
        degreeGrid - grid for degree balanced cross-validation subsets that is proportions between classes in subsets are close to such proportion in the whole train dataset. The method trains the %SVM model automatically by choosing the optimal parameters C, gamma, p, nu, coef0, degree. Parameters are considered optimal when the cross-validation estimate of the test set error is minimal. This function only makes use of SVM::getDefaultGrid for parameter optimization and thus only offers rudimentary parameter options. This function works for the classification (SVM::C_SVC or SVM::NU_SVC) as well as for the regression (SVM::EPS_SVR or SVM::NU_SVR). If it is SVM::ONE_CLASS, no optimization is made and the usual %SVM with parameters specified in params is executed.
        Returns:
        automatically generated
      • trainAuto

        public boolean trainAuto​(Mat samples,
                                 int layout,
                                 Mat responses,
                                 int kFold,
                                 ParamGrid Cgrid,
                                 ParamGrid gammaGrid,
                                 ParamGrid pGrid,
                                 ParamGrid nuGrid,
                                 ParamGrid coeffGrid)
        Trains an %SVM with optimal parameters
        Parameters:
        samples - training samples
        layout - See ml::SampleTypes.
        responses - vector of responses associated with the training samples.
        kFold - Cross-validation parameter. The training set is divided into kFold subsets. One subset is used to test the model, the others form the train set. So, the %SVM algorithm is
        Cgrid - grid for C
        gammaGrid - grid for gamma
        pGrid - grid for p
        nuGrid - grid for nu
        coeffGrid - grid for coeff balanced cross-validation subsets that is proportions between classes in subsets are close to such proportion in the whole train dataset. The method trains the %SVM model automatically by choosing the optimal parameters C, gamma, p, nu, coef0, degree. Parameters are considered optimal when the cross-validation estimate of the test set error is minimal. This function only makes use of SVM::getDefaultGrid for parameter optimization and thus only offers rudimentary parameter options. This function works for the classification (SVM::C_SVC or SVM::NU_SVC) as well as for the regression (SVM::EPS_SVR or SVM::NU_SVR). If it is SVM::ONE_CLASS, no optimization is made and the usual %SVM with parameters specified in params is executed.
        Returns:
        automatically generated
      • trainAuto

        public boolean trainAuto​(Mat samples,
                                 int layout,
                                 Mat responses,
                                 int kFold,
                                 ParamGrid Cgrid,
                                 ParamGrid gammaGrid,
                                 ParamGrid pGrid,
                                 ParamGrid nuGrid)
        Trains an %SVM with optimal parameters
        Parameters:
        samples - training samples
        layout - See ml::SampleTypes.
        responses - vector of responses associated with the training samples.
        kFold - Cross-validation parameter. The training set is divided into kFold subsets. One subset is used to test the model, the others form the train set. So, the %SVM algorithm is
        Cgrid - grid for C
        gammaGrid - grid for gamma
        pGrid - grid for p
        nuGrid - grid for nu balanced cross-validation subsets that is proportions between classes in subsets are close to such proportion in the whole train dataset. The method trains the %SVM model automatically by choosing the optimal parameters C, gamma, p, nu, coef0, degree. Parameters are considered optimal when the cross-validation estimate of the test set error is minimal. This function only makes use of SVM::getDefaultGrid for parameter optimization and thus only offers rudimentary parameter options. This function works for the classification (SVM::C_SVC or SVM::NU_SVC) as well as for the regression (SVM::EPS_SVR or SVM::NU_SVR). If it is SVM::ONE_CLASS, no optimization is made and the usual %SVM with parameters specified in params is executed.
        Returns:
        automatically generated
      • trainAuto

        public boolean trainAuto​(Mat samples,
                                 int layout,
                                 Mat responses,
                                 int kFold,
                                 ParamGrid Cgrid,
                                 ParamGrid gammaGrid,
                                 ParamGrid pGrid)
        Trains an %SVM with optimal parameters
        Parameters:
        samples - training samples
        layout - See ml::SampleTypes.
        responses - vector of responses associated with the training samples.
        kFold - Cross-validation parameter. The training set is divided into kFold subsets. One subset is used to test the model, the others form the train set. So, the %SVM algorithm is
        Cgrid - grid for C
        gammaGrid - grid for gamma
        pGrid - grid for p balanced cross-validation subsets that is proportions between classes in subsets are close to such proportion in the whole train dataset. The method trains the %SVM model automatically by choosing the optimal parameters C, gamma, p, nu, coef0, degree. Parameters are considered optimal when the cross-validation estimate of the test set error is minimal. This function only makes use of SVM::getDefaultGrid for parameter optimization and thus only offers rudimentary parameter options. This function works for the classification (SVM::C_SVC or SVM::NU_SVC) as well as for the regression (SVM::EPS_SVR or SVM::NU_SVR). If it is SVM::ONE_CLASS, no optimization is made and the usual %SVM with parameters specified in params is executed.
        Returns:
        automatically generated
      • trainAuto

        public boolean trainAuto​(Mat samples,
                                 int layout,
                                 Mat responses,
                                 int kFold,
                                 ParamGrid Cgrid,
                                 ParamGrid gammaGrid)
        Trains an %SVM with optimal parameters
        Parameters:
        samples - training samples
        layout - See ml::SampleTypes.
        responses - vector of responses associated with the training samples.
        kFold - Cross-validation parameter. The training set is divided into kFold subsets. One subset is used to test the model, the others form the train set. So, the %SVM algorithm is
        Cgrid - grid for C
        gammaGrid - grid for gamma balanced cross-validation subsets that is proportions between classes in subsets are close to such proportion in the whole train dataset. The method trains the %SVM model automatically by choosing the optimal parameters C, gamma, p, nu, coef0, degree. Parameters are considered optimal when the cross-validation estimate of the test set error is minimal. This function only makes use of SVM::getDefaultGrid for parameter optimization and thus only offers rudimentary parameter options. This function works for the classification (SVM::C_SVC or SVM::NU_SVC) as well as for the regression (SVM::EPS_SVR or SVM::NU_SVR). If it is SVM::ONE_CLASS, no optimization is made and the usual %SVM with parameters specified in params is executed.
        Returns:
        automatically generated
      • trainAuto

        public boolean trainAuto​(Mat samples,
                                 int layout,
                                 Mat responses,
                                 int kFold,
                                 ParamGrid Cgrid)
        Trains an %SVM with optimal parameters
        Parameters:
        samples - training samples
        layout - See ml::SampleTypes.
        responses - vector of responses associated with the training samples.
        kFold - Cross-validation parameter. The training set is divided into kFold subsets. One subset is used to test the model, the others form the train set. So, the %SVM algorithm is
        Cgrid - grid for C balanced cross-validation subsets that is proportions between classes in subsets are close to such proportion in the whole train dataset. The method trains the %SVM model automatically by choosing the optimal parameters C, gamma, p, nu, coef0, degree. Parameters are considered optimal when the cross-validation estimate of the test set error is minimal. This function only makes use of SVM::getDefaultGrid for parameter optimization and thus only offers rudimentary parameter options. This function works for the classification (SVM::C_SVC or SVM::NU_SVC) as well as for the regression (SVM::EPS_SVR or SVM::NU_SVR). If it is SVM::ONE_CLASS, no optimization is made and the usual %SVM with parameters specified in params is executed.
        Returns:
        automatically generated
      • trainAuto

        public boolean trainAuto​(Mat samples,
                                 int layout,
                                 Mat responses,
                                 int kFold)
        Trains an %SVM with optimal parameters
        Parameters:
        samples - training samples
        layout - See ml::SampleTypes.
        responses - vector of responses associated with the training samples.
        kFold - Cross-validation parameter. The training set is divided into kFold subsets. One subset is used to test the model, the others form the train set. So, the %SVM algorithm is balanced cross-validation subsets that is proportions between classes in subsets are close to such proportion in the whole train dataset. The method trains the %SVM model automatically by choosing the optimal parameters C, gamma, p, nu, coef0, degree. Parameters are considered optimal when the cross-validation estimate of the test set error is minimal. This function only makes use of SVM::getDefaultGrid for parameter optimization and thus only offers rudimentary parameter options. This function works for the classification (SVM::C_SVC or SVM::NU_SVC) as well as for the regression (SVM::EPS_SVR or SVM::NU_SVR). If it is SVM::ONE_CLASS, no optimization is made and the usual %SVM with parameters specified in params is executed.
        Returns:
        automatically generated
      • trainAuto

        public boolean trainAuto​(Mat samples,
                                 int layout,
                                 Mat responses)
        Trains an %SVM with optimal parameters
        Parameters:
        samples - training samples
        layout - See ml::SampleTypes.
        responses - vector of responses associated with the training samples. subset is used to test the model, the others form the train set. So, the %SVM algorithm is balanced cross-validation subsets that is proportions between classes in subsets are close to such proportion in the whole train dataset. The method trains the %SVM model automatically by choosing the optimal parameters C, gamma, p, nu, coef0, degree. Parameters are considered optimal when the cross-validation estimate of the test set error is minimal. This function only makes use of SVM::getDefaultGrid for parameter optimization and thus only offers rudimentary parameter options. This function works for the classification (SVM::C_SVC or SVM::NU_SVC) as well as for the regression (SVM::EPS_SVR or SVM::NU_SVR). If it is SVM::ONE_CLASS, no optimization is made and the usual %SVM with parameters specified in params is executed.
        Returns:
        automatically generated
      • getSupportVectors

        public Mat getSupportVectors()
        Retrieves all the support vectors The method returns all the support vectors as a floating-point matrix, where support vectors are stored as matrix rows.
        Returns:
        automatically generated
      • getUncompressedSupportVectors

        public Mat getUncompressedSupportVectors()
        Retrieves all the uncompressed support vectors of a linear %SVM The method returns all the uncompressed support vectors of a linear %SVM that the compressed support vector, used for prediction, was derived from. They are returned in a floating-point matrix, where the support vectors are stored as matrix rows.
        Returns:
        automatically generated
      • getDecisionFunction

        public double getDecisionFunction​(int i,
                                          Mat alpha,
                                          Mat svidx)
        Retrieves the decision function
        Parameters:
        i - the index of the decision function. If the problem solved is regression, 1-class or 2-class classification, then there will be just one decision function and the index should always be 0. Otherwise, in the case of N-class classification, there will be \(N(N-1)/2\) decision functions.
        alpha - the optional output vector for weights, corresponding to different support vectors. In the case of linear %SVM all the alpha's will be 1's.
        svidx - the optional output vector of indices of support vectors within the matrix of support vectors (which can be retrieved by SVM::getSupportVectors). In the case of linear %SVM each decision function consists of a single "compressed" support vector. The method returns rho parameter of the decision function, a scalar subtracted from the weighted sum of kernel responses.
        Returns:
        automatically generated
      • getDefaultGridPtr

        public static ParamGrid getDefaultGridPtr​(int param_id)
        Generates a grid for %SVM parameters.
        Parameters:
        param_id - %SVM parameters IDs that must be one of the SVM::ParamTypes. The grid is generated for the parameter with this ID. The function generates a grid pointer for the specified parameter of the %SVM algorithm. The grid may be passed to the function SVM::trainAuto.
        Returns:
        automatically generated
      • create

        public static SVM create()
        Creates empty model. Use StatModel::train to train the model. Since %SVM has several parameters, you may want to find the best parameters for your problem, it can be done with SVM::trainAuto.
        Returns:
        automatically generated
      • load

        public static SVM load​(java.lang.String filepath)
        Loads and creates a serialized svm from a file Use SVM::save to serialize and store an SVM to disk. Load the SVM from this file again, by calling this function with the path to the file.
        Parameters:
        filepath - path to serialized svm
        Returns:
        automatically generated
      • finalize

        protected void finalize()
                         throws java.lang.Throwable
        Overrides:
        finalize in class StatModel
        Throws:
        java.lang.Throwable