Segfault with large feature vector LibSVM

Question

I am running LibSVM on an Android application (NDK). I have implemented similar code on a Mac application that works well for all feature vector sizes. When I give a vector of 408 features, I have no problems doing multi-class classification. Anything 409 or higher, though, and (I will eventually be putting in 16800) seems to fail here:

0-16 23:28:41.084 30997-31028/? A/libc: Fatal signal 11 (SIGSEGV), code 1, fault addr 0xaf000000 in tid 31028 (GLThread 17147)
10-16 23:28:41.190 27393-27393/? I/DEBUG: *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
10-16 23:28:41.191 27393-27393/? I/DEBUG: Build fingerprint: 'google/hammerhead/hammerhead:5.1.1/LMY48M/2167285:user/release-keys'
10-16 23:28:41.191 27393-27393/? I/DEBUG: Revision: '11'
10-16 23:28:41.191 27393-27393/? I/DEBUG: ABI: 'arm'
10-16 23:28:41.191 27393-27393/? I/DEBUG: pid: 30997, tid: 31028, name: GLThread 17147  >>> cc.openframeworks.androidEmptyExample <<<
10-16 23:28:41.191 27393-27393/? I/DEBUG: signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0xaf000000
10-16 23:28:41.202 27393-27393/? I/DEBUG:     r0 aef3e000  r1 aef5ed10  r2 00000001  r3 af000000
10-16 23:28:41.202 27393-27393/? I/DEBUG:     r4 aec29eb8  r5 00000001  r6 b4b2c608  r7 12d090c0
10-16 23:28:41.202 27393-27393/? I/DEBUG:     r8 12d15660  r9 b4a39400  sl 00000000  fp af37d824
10-16 23:28:41.202 27393-27393/? I/DEBUG:     ip b6e417dc  sp af37d810  lr a301ff78  pc a301ff04  cpsr 000f0010
10-16 23:28:41.202 27393-27393/? I/DEBUG:     #00 pc 00167f04  /data/app/cc.openframeworks.androidEmptyExample-1/lib/arm/libOFAndroidApp.so (Kernel::dot(svm_node const*, svm_node const*)+192)

Here's the relevant code that I'm learning with:

ofxSvm mSvm;
void ofApp::update()
{ //Runs in loop            
    for(int i =0; i<8400; ++i)
    {
        HandDataVector.push_back((double)tempValue[i]);//tempValue is   incoming data from a serial port (8400 doubles per packet)
    }
    //If I exclude this I get segfaults:
    HandDataVector.resize(150);
    if(learningToggleBoxTicked)
    {
        mSvm.addData(HandDataVector,label)
        mSvm.train();
    } else {
        ofLogNotice("Classified As")<< mSvm.classify();
    }
}

int ofApp::classify()
{
    return mSvm.predict(HandDataVector);
}

Here's the ofxSvm Library I'm using

    int ofxSvm::addData(int label, vector<double>& vec)
    {
            checkDimension(vec.size());

            mData.insert(make_pair(label, vec));
            mDimension = vec.size();


            stringstream ss;
            for (const auto v : vec) ss << v << " ";
            ss << "EOS";
            ofLogNotice(LOG_MODULE, "add data, label: " + ofToString(label) + " size: "+ofToString(vec.size())+" vec: " + ss.str());


            return mData.size();
   }
   void ofxSvm::train()
   {


            svm_problem prob;

            prob.l = mData.size();

            prob.y = new double[prob.l];
            {
                data_type::iterator it = mData.begin();
                int i = 0;
                while (it != mData.end())
                {
                    prob.y[i] = it->first;
                    ++it; ++i;
                }
            }


            if(mParam.gamma == 0)
            {
                mParam.gamma = 1.0 / mDimension;
            }

            int nodeLength = mDimension + 1;
            svm_node* node = new svm_node[prob.l * nodeLength];
            prob.x = new svm_node*[prob.l];
            {
                data_type::iterator it = mData.begin();
                int i = 0;
                while (it != mData.end())
                {
                    prob.x[i] = node + i * nodeLength;
                    for (int j = 0; j < mDimension; ++j)
                    {
                        prob.x[i][j].index = j + 1;
                        prob.x[i][j].value = it->second[j];
                    }
                    prob.x[i][mDimension].index = -1; // delimiter
                    ++it; ++i;
                }
            }

            ofLogNotice(LOG_MODULE, "Start train...");

            mModel = svm_train(&prob, &mParam);



            ofLogNotice(LOG_MODULE, "Finished train!");

            int x = mModel->nr_class;

            ofLogNotice("TRAINED MODEL LABELS: " + ofToString(x));

            delete[] node;
            delete[] prob.x;
            delete[] prob.y;
        }

        int ofxSvm::predict(vector<double>& testVec)
        {
            if (mModel == NULL)
            {
                ofLogNotice(LOG_MODULE, "null model, before do train or load model file");
                return -5;
            }
            if (testVec.size() != mDimension)
            {
                ofLogNotice(LOG_MODULE, "different dimension");
                return -6;
            }


            svm_node* node = new svm_node[mDimension + 1];
            for (int i = 0; i < mDimension; ++i)
            {
                node[i].index = i + 1;
                node[i].value = testVec[i];
                ofLogNotice("node") << node[i].value <<"-" << i;

            }
            node[mDimension].index = -1;

            int res = static_cast<int>(svm_predict(mModel, node));


            stringstream ss;
            for (const auto v : testVec) ss << v << " ";
            ss << "EOS";
            ofLogNotice(LOG_MODULE, "add data, label: size: "+ofToString(testVec.size())+" vec: " + ss.str());


            ofLogNotice("ANSWER")<< res;


            delete[] node;
            return res;
    }

Here's the function in the LibSVM library the fault is happening in:

double Kernel::dot(const svm_node *px, const svm_node *py)
{
    double sum = 0;
    while(px->index != -1 && py->index != -1)
    {
        if(px->index == py->index)
        {
            sum += px->value * py->value;
            ++px;
            ++py;
        }
        else
        {
            if(px->index > py->index)
                ++py;
            else
                ++px;
        }
    }
    return sum;
}

EDIT: Here's where the dot function is called (k_function in svm_predict_values)

double svm_predict_values(const svm_model *model, const svm_node *x, double* dec_values)
{
    int i;
    if(model->param.svm_type == ONE_CLASS ||
       model->param.svm_type == EPSILON_SVR ||
       model->param.svm_type == NU_SVR)
    {
        double *sv_coef = model->sv_coef[0];
        double sum = 0;
        for(i=0;i<model->l;i++)
            sum += sv_coef[i] * Kernel::k_function(x,model->SV[i],model->param);
        sum -= model->rho[0];
        *dec_values = sum;

        if(model->param.svm_type == ONE_CLASS)
            return (sum>0)?1:-1;
        else
            return sum;
    }
    else
    {
        int nr_class = model->nr_class;
        int l = model->l;

        double *kvalue = Malloc(double,l);
        for(i=0;i<l;i++)
            kvalue[i] = Kernel::k_function(x,model->SV[i],model->param);

        int *start = Malloc(int,nr_class);
        start[0] = 0;
        for(i=1;i<nr_class;i++)
            start[i] = start[i-1]+model->nSV[i-1];

        int *vote = Malloc(int,nr_class);
        for(i=0;i<nr_class;i++)
            vote[i] = 0;

        int p=0;
        for(i=0;i<nr_class;i++)
            for(int j=i+1;j<nr_class;j++)
            {
                double sum = 0;
                int si = start[i];
                int sj = start[j];
                int ci = model->nSV[i];
                int cj = model->nSV[j];

                int k;
                double *coef1 = model->sv_coef[j-1];
                double *coef2 = model->sv_coef[i];
                for(k=0;k<ci;k++)
                    sum += coef1[si+k] * kvalue[si+k];
                for(k=0;k<cj;k++)
                    sum += coef2[sj+k] * kvalue[sj+k];
                sum -= model->rho[p];
                dec_values[p] = sum;

                if(dec_values[p] > 0)
                    ++vote[i];
                else
                    ++vote[j];
                p++;
            }

        int vote_max_idx = 0;
        for(i=1;i<nr_class;i++)
            if(vote[i] > vote[vote_max_idx])
                vote_max_idx = i;

        free(kvalue);
        free(start);
        free(vote);
        return model->label[vote_max_idx];
    }
}

double Kernel::k_function(const svm_node *x, const svm_node *y,
                          const svm_parameter& param)
{
    switch(param.kernel_type)
    {
        case LINEAR:
            return dot(x,y);
        case POLY:
            return powi(param.gamma*dot(x,y)+param.coef0,param.degree);
        case RBF:
        {
            double sum = 0;
            while(x->index != -1 && y->index !=-1)
            {
                if(x->index == y->index)
                {
                    double d = x->value - y->value;
                    sum += d*d;
                    ++x;
                    ++y;
                }
                else
                {
                    if(x->index > y->index)
                    {
                        sum += y->value * y->value;
                        ++y;
                    }
                    else
                    {
                        sum += x->value * x->value;
                        ++x;
                    }
                }
            }

            while(x->index != -1)
            {
                sum += x->value * x->value;
                ++x;
            }

            while(y->index != -1)
            {
                sum += y->value * y->value;
                ++y;
            }

            return exp(-param.gamma*sum);
        }
        case SIGMOID:
            return tanh(param.gamma*dot(x,y)+param.coef0);
        case PRECOMPUTED:  //x: test (validation), y: SV
            return x[(int)(y->value)].value;
        default:
            return 0;  // Unreachable 
    }
}

    double kernel_linear(int i, int j) const
    {
        return dot(x[i],x[j]);
    }

Where's `dot` called from? You're walking one or both of you pointer past the end of allocated memory. — 1201ProgramAlarm, Oct 17 '15 at 04:14
@1201ProgramAlarm It's called from the LibSVM library after calling svm_predict. It's art of the algorithm. Just added it to the edit. Which one do you think is walking past the allocated memory? — Rohan, Oct 17 '15 at 17:06
You aren't checking the return from malloc? If malloc cannot allocate the requested memory this will return nullptr and you will get a SEGV when you try to access the memory. — Ben, Oct 20 '15 at 17:08
@Ben from malloc'ing which variable? Which one should I be checking? — Rohan, Oct 20 '15 at 17:11
@Roham All of them. SIGSEGV. invalid memory access (segmentation fault) — user430051, Oct 21 '15 at 18:00

score 1 · Answer 1 · answered Oct 26 '15 at 12:26

Introduction

I had a very hard time finding any documentation about libSVM in c++. So my answer is mostly based on the code you showed us without real reference documentation.

If you could post a link to your documentation it would be very helpful :)

Potential issue

You showed the code where you initialize the svm_node* in your training code:

prob.x[i][mDimension].index = -1;

You're initializing an svm_probleminstance. And apparently in your dot() function you expect to see such nodes with a negative index to mark the end of the svm_node list.

But you code fails when called like this:

Kernel::k_function(x,model->SV[i],model->param);

Here, model is an svm_model, not an svm_problem, so I guess this is returned by the libSVM after you trained the model. Are you sure the svm_model follows the convention of using node->index = -1 to mark the end of the node list ?

So maybe the marker node just doesn't exist and you run out of bound.

Why does it break suddenly for 409 items

The signal you get is a SIGSEGV which indicates that you tried to access a byte in a page not mapped in your process.

When accessing items out of bound you usually don't get a SIGSEGV, because the previously allocated item is in the middle of a memory page, and there are enough bytes after it in the page. It may happens that the 409th item was just after the currently allocated page, triggering the signal.

score 0 · Answer 2 · answered Apr 04 '20 at 19:34

I had a similar issue in 'dot' function, and I solved by not including '0' as a value. As @fjardon mentioned, the function is expecting an index of '-1' and a value of '0' to mark the end of the list of svm_nodes (training vector).

For sure it is a bit late for you but hopefully it will help future libsvm users :)

Segfault with large feature vector LibSVM

2 Answers2