Make OpenCV 3.1 Training SVM faster ( Use GPU or MultiThreading ? ) - C++
<pre><code>#include &lt;iostream&gt;
#include &lt;opencv2/core.hpp&gt;
#include &lt;opencv2/imgproc.hpp&gt;
#include "opencv2/imgcodecs.hpp"
#include &lt;opencv2/highgui.hpp&gt;
#include &lt;opencv2/ml.hpp&gt;
#define NTRAINING_SAMPLES   100         // Number of training samples per class
#define FRAC_LINEAR_SEP     0.5f        // Fraction of samples which compose the linear separable part
using namespace cv;
using namespace cv::ml;
using namespace std;
static void help()
{
    cout&lt;&lt; "\n--------------------------------------------------------------------------" &lt;&lt; endl
        &lt;&lt; "This program shows Support Vector Machines for Non-Linearly Separable Data. " &lt;&lt; endl
        &lt;&lt; "Usage:"                                                               &lt;&lt; endl
        &lt;&lt; "./non_linear_svms" &lt;&lt; endl
        &lt;&lt; "--------------------------------------------------------------------------"   &lt;&lt; endl
        &lt;&lt; endl;
}
int main()
{
    help();
    // Data for visual representation
    const int WIDTH = 512, HEIGHT = 512;
    Mat I = Mat::zeros(HEIGHT, WIDTH, CV_8UC3);
    //--------------------- 1. Set up training data randomly ---------------------------------------
    Mat trainData(2*NTRAINING_SAMPLES, 2, CV_32FC1);
    Mat labels   (2*NTRAINING_SAMPLES, 1, CV_32SC1);
    RNG rng(100); // Random value generation class
    // Set up the linearly separable part of the training data
    int nLinearSamples = (int) (FRAC_LINEAR_SEP * NTRAINING_SAMPLES);
    // Generate random points for the class 1
    Mat trainClass = trainData.rowRange(0, nLinearSamples);
    // The x coordinate of the points is in [0, 0.4)
    Mat c = trainClass.colRange(0, 1);
    rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(0.4 * WIDTH));
    // The y coordinate of the points is in [0, 1)
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));
    // Generate random points for the class 2
    trainClass = trainData.rowRange(2*NTRAINING_SAMPLES-nLinearSamples, 2*NTRAINING_SAMPLES);
    // The x coordinate of the points is in [0.6, 1]
    c = trainClass.colRange(0 , 1);
    rng.fill(c, RNG::UNIFORM, Scalar(0.6*WIDTH), Scalar(WIDTH));
    // The y coordinate of the points is in [0, 1)
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));
    //------------------ Set up the non-linearly separable part of the training data ---------------
    // Generate random points for the classes 1 and 2
    trainClass = trainData.rowRange(  nLinearSamples, 2*NTRAINING_SAMPLES-nLinearSamples);
    // The x coordinate of the points is in [0.4, 0.6)
    c = trainClass.colRange(0,1);
    rng.fill(c, RNG::UNIFORM, Scalar(0.4*WIDTH), Scalar(0.6*WIDTH));
    // The y coordinate of the points is in [0, 1)
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));
    //------------------------- Set up the labels for the classes ---------------------------------
    labels.rowRange(                0,   NTRAINING_SAMPLES).setTo(1);  // Class 1
    labels.rowRange(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES).setTo(2);  // Class 2
    //------------------------ 2. Set up the support vector machines parameters --------------------
    //------------------------ 3. Train the svm ----------------------------------------------------
    cout &lt;&lt; "Starting training process" &lt;&lt; endl;
    Ptr&lt;SVM&gt; svm = SVM::create();
    svm-&gt;setType(SVM::C_SVC);
    //svm-&gt;setC(0.1);

    vector&lt;float&gt; weights;
    weights.push_back( 1 );
    weights.push_back( 1 );
    Mat w(weights);
    svm-&gt;setClassWeights(w);

    svm-&gt;setKernel(SVM::INTER);
    svm-&gt;setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, (int)1e7, 1e-6));


  //  svm-&gt;train(trainData, ROW_SAMPLE, labels);


    _InputArray tr_data1(trainData);
    _InputArray lab(labels);
    Ptr&lt;TrainData&gt; trainData_ptr = TrainData::create(tr_data1 , ROW_SAMPLE , lab);
    svm-&gt;trainAuto(trainData_ptr);



    cout &lt;&lt; "Finished training process" &lt;&lt; endl;
    //------------------------ 4. Show the decision regions ----------------------------------------
    Vec3b green(0,100,0), blue (100,0,0);
    for (int i = 0; i &lt; I.rows; ++i)
        for (int j = 0; j &lt; I.cols; ++j)
        {
            Mat sampleMat = (Mat_&lt;float&gt;(1,2) &lt;&lt; i, j);
            float response = svm-&gt;predict(sampleMat);
            if      (response == 1)    I.at&lt;Vec3b&gt;(j, i)  = green;
            else if (response == 2)    I.at&lt;Vec3b&gt;(j, i)  = blue;
        }
    //----------------------- 5. Show the training data --------------------------------------------
    int thick = -1;
    int lineType = 8;
    float px, py;
    // Class 1
    for (int i = 0; i &lt; NTRAINING_SAMPLES; ++i)
    {
        px = trainData.at&lt;float&gt;(i,0);
        py = trainData.at&lt;float&gt;(i,1);
        circle(I, Point( (int) px,  (int) py ), 3, Scalar(0, 255, 0), thick, lineType);
    }
    // Class 2
    for (int i = NTRAINING_SAMPLES; i &lt;2*NTRAINING_SAMPLES; ++i)
    {
        px = trainData.at&lt;float&gt;(i,0);
        py = trainData.at&lt;float&gt;(i,1);
        circle(I, Point( (int) px, (int) py ), 3, Scalar(255, 0, 0), thick, lineType);
    }
    //------------------------- 6. Show support vectors --------------------------------------------
    thick = 2;
    lineType  = 8;
    Mat sv = svm-&gt;getSupportVectors();
    for (int i = 0; i &lt; sv.rows; ++i)
    {
        const float* v = sv.ptr&lt;float&gt;(i);
        circle( I,  Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thick, lineType);
    }


    cout &lt;&lt; endl &lt;&lt; " C: "&lt;&lt; svm-&gt;getC() &lt;&lt;endl ;


    imwrite("result.png", I);                      // save the Image
    imshow("SVM for Non-Linear Training Data", I); // show it to the user
    waitKey(0);
}
</code></pre>

<p><strong>Currently running this code --> Which uses SVM::train_auto() method takes hours to finish ! 
So is there a way to make it run on GPU or Multi-thread it ?</strong></p>

<p><em>The above is just a demo example , but I want to make my SVM train on image datasets where I have -> 4096 features for each image and so I was planning to use train auto to optimize the SVM_C and SVM_NU parameter , assuming it does. If not is there a way I can optimize those parameters ?</em></p>

<p>Thanks In Advance.</p>