svm_model_matlab.c

Go to the documentation of this file.

#include <stdlib.h>
#include <string.h>
#include "../svm.h"

#include "mex.h"

#ifdef MX_API_VER
#if MX_API_VER < 0x07030000
typedef int mwIndex;
#endif
#endif

#define NUM_OF_RETURN_FIELD 11

#define Malloc(type,n) (type *)malloc((n)*sizeof(type))

static const char *field_names[] = {
        "Parameters",
        "nr_class",
        "totalSV",
        "rho",
        "Label",
        "sv_indices",
        "ProbA",
        "ProbB",
        "nSV",
        "sv_coef",
        "SVs"
};

const char *model_to_matlab_structure(mxArray *plhs[], int num_of_feature, struct svm_model *model)
{
        int i, j, n;
        double *ptr;
        mxArray *return_model, **rhs;
        int out_id = 0;

        rhs = (mxArray **)mxMalloc(sizeof(mxArray *)*NUM_OF_RETURN_FIELD);

        // Parameters
        rhs[out_id] = mxCreateDoubleMatrix(5, 1, mxREAL);
        ptr = mxGetPr(rhs[out_id]);
        ptr[0] = model->param.svm_type;
        ptr[1] = model->param.kernel_type;
        ptr[2] = model->param.degree;
        ptr[3] = model->param.gamma;
        ptr[4] = model->param.coef0;
        out_id++;

        // nr_class
        rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL);
        ptr = mxGetPr(rhs[out_id]);
        ptr[0] = model->nr_class;
        out_id++;

        // total SV
        rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL);
        ptr = mxGetPr(rhs[out_id]);
        ptr[0] = model->l;
        out_id++;

        // rho
        n = model->nr_class*(model->nr_class-1)/2;
        rhs[out_id] = mxCreateDoubleMatrix(n, 1, mxREAL);
        ptr = mxGetPr(rhs[out_id]);
        for(i = 0; i < n; i++)
                ptr[i] = model->rho[i];
        out_id++;

        // Label
        if(model->label)
        {
                rhs[out_id] = mxCreateDoubleMatrix(model->nr_class, 1, mxREAL);
                ptr = mxGetPr(rhs[out_id]);
                for(i = 0; i < model->nr_class; i++)
                        ptr[i] = model->label[i];
        }
        else
                rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL);
        out_id++;

        // sv_indices
        if(model->sv_indices)
        {
                rhs[out_id] = mxCreateDoubleMatrix(model->l, 1, mxREAL);
                ptr = mxGetPr(rhs[out_id]);
                for(i = 0; i < model->l; i++)
                        ptr[i] = model->sv_indices[i];
        }
        else
                rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL);
        out_id++;

        // probA
        if(model->probA != NULL)
        {
                rhs[out_id] = mxCreateDoubleMatrix(n, 1, mxREAL);
                ptr = mxGetPr(rhs[out_id]);
                for(i = 0; i < n; i++)
                        ptr[i] = model->probA[i];
        }
        else
                rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL);
        out_id ++;

        // probB
        if(model->probB != NULL)
        {
                rhs[out_id] = mxCreateDoubleMatrix(n, 1, mxREAL);
                ptr = mxGetPr(rhs[out_id]);
                for(i = 0; i < n; i++)
                        ptr[i] = model->probB[i];
        }
        else
                rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL);
        out_id++;

        // nSV
        if(model->nSV)
        {
                rhs[out_id] = mxCreateDoubleMatrix(model->nr_class, 1, mxREAL);
                ptr = mxGetPr(rhs[out_id]);
                for(i = 0; i < model->nr_class; i++)
                        ptr[i] = model->nSV[i];
        }
        else
                rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL);
        out_id++;

        // sv_coef
        rhs[out_id] = mxCreateDoubleMatrix(model->l, model->nr_class-1, mxREAL);
        ptr = mxGetPr(rhs[out_id]);
        for(i = 0; i < model->nr_class-1; i++)
                for(j = 0; j < model->l; j++)
                        ptr[(i*(model->l))+j] = model->sv_coef[i][j];
        out_id++;

        // SVs
        {
                int ir_index, nonzero_element;
                mwIndex *ir, *jc;
                mxArray *pprhs[1], *pplhs[1];   

                if(model->param.kernel_type == PRECOMPUTED)
                {
                        nonzero_element = model->l;
                        num_of_feature = 1;
                }
                else
                {
                        nonzero_element = 0;
                        for(i = 0; i < model->l; i++) {
                                j = 0;
                                while(model->SV[i][j].index != -1) 
                                {
                                        nonzero_element++;
                                        j++;
                                }
                        }
                }

                // SV in column, easier accessing
                rhs[out_id] = mxCreateSparse(num_of_feature, model->l, nonzero_element, mxREAL);
                ir = mxGetIr(rhs[out_id]);
                jc = mxGetJc(rhs[out_id]);
                ptr = mxGetPr(rhs[out_id]);
                jc[0] = ir_index = 0;           
                for(i = 0;i < model->l; i++)
                {
                        if(model->param.kernel_type == PRECOMPUTED)
                        {
                                // make a (1 x model->l) matrix
                                ir[ir_index] = 0; 
                                ptr[ir_index] = model->SV[i][0].value;
                                ir_index++;
                                jc[i+1] = jc[i] + 1;
                        }
                        else
                        {
                                int x_index = 0;
                                while (model->SV[i][x_index].index != -1)
                                {
                                        ir[ir_index] = model->SV[i][x_index].index - 1; 
                                        ptr[ir_index] = model->SV[i][x_index].value;
                                        ir_index++, x_index++;
                                }
                                jc[i+1] = jc[i] + x_index;
                        }
                }
                // transpose back to SV in row
                pprhs[0] = rhs[out_id];
                if(mexCallMATLAB(1, pplhs, 1, pprhs, "transpose"))
                        return "cannot transpose SV matrix";
                rhs[out_id] = pplhs[0];
                out_id++;
        }

        /* Create a struct matrix contains NUM_OF_RETURN_FIELD fields */
        return_model = mxCreateStructMatrix(1, 1, NUM_OF_RETURN_FIELD, field_names);

        /* Fill struct matrix with input arguments */
        for(i = 0; i < NUM_OF_RETURN_FIELD; i++)
                mxSetField(return_model,0,field_names[i],mxDuplicateArray(rhs[i]));
        /* return */
        plhs[0] = return_model;
        mxFree(rhs);

        return NULL;
}

struct svm_model *matlab_matrix_to_model(const mxArray *matlab_struct, const char **msg)
{
        int i, j, n, num_of_fields;
        double *ptr;
        int id = 0;
        struct svm_node *x_space;
        struct svm_model *model;
        mxArray **rhs;

        num_of_fields = mxGetNumberOfFields(matlab_struct);
        if(num_of_fields != NUM_OF_RETURN_FIELD) 
        {
                *msg = "number of return field is not correct";
                return NULL;
        }
        rhs = (mxArray **) mxMalloc(sizeof(mxArray *)*num_of_fields);

        for(i=0;i<num_of_fields;i++)
                rhs[i] = mxGetFieldByNumber(matlab_struct, 0, i);

        model = Malloc(struct svm_model, 1);
        model->rho = NULL;
        model->probA = NULL;
        model->probB = NULL;
        model->label = NULL;
        model->sv_indices = NULL;
        model->nSV = NULL;
        model->free_sv = 1; // XXX

        ptr = mxGetPr(rhs[id]);
        model->param.svm_type = (int)ptr[0];
        model->param.kernel_type  = (int)ptr[1];
        model->param.degree       = (int)ptr[2];
        model->param.gamma        = ptr[3];
        model->param.coef0        = ptr[4];
        id++;

        ptr = mxGetPr(rhs[id]);
        model->nr_class = (int)ptr[0];
        id++;

        ptr = mxGetPr(rhs[id]);
        model->l = (int)ptr[0];
        id++;

        // rho
        n = model->nr_class * (model->nr_class-1)/2;
        model->rho = (double*) malloc(n*sizeof(double));
        ptr = mxGetPr(rhs[id]);
        for(i=0;i<n;i++)
                model->rho[i] = ptr[i];
        id++;

        // label
        if(mxIsEmpty(rhs[id]) == 0)
        {
                model->label = (int*) malloc(model->nr_class*sizeof(int));
                ptr = mxGetPr(rhs[id]);
                for(i=0;i<model->nr_class;i++)
                        model->label[i] = (int)ptr[i];
        }
        id++;

        // sv_indices
        if(mxIsEmpty(rhs[id]) == 0)
        {
                model->sv_indices = (int*) malloc(model->l*sizeof(int));
                ptr = mxGetPr(rhs[id]);
                for(i=0;i<model->l;i++)
                        model->sv_indices[i] = (int)ptr[i];
        }
        id++;

        // probA
        if(mxIsEmpty(rhs[id]) == 0)
        {
                model->probA = (double*) malloc(n*sizeof(double));
                ptr = mxGetPr(rhs[id]);
                for(i=0;i<n;i++)
                        model->probA[i] = ptr[i];
        }
        id++;

        // probB
        if(mxIsEmpty(rhs[id]) == 0)
        {
                model->probB = (double*) malloc(n*sizeof(double));
                ptr = mxGetPr(rhs[id]);
                for(i=0;i<n;i++)
                        model->probB[i] = ptr[i];
        }
        id++;

        // nSV
        if(mxIsEmpty(rhs[id]) == 0)
        {
                model->nSV = (int*) malloc(model->nr_class*sizeof(int));
                ptr = mxGetPr(rhs[id]);
                for(i=0;i<model->nr_class;i++)
                        model->nSV[i] = (int)ptr[i];
        }
        id++;

        // sv_coef
        ptr = mxGetPr(rhs[id]);
        model->sv_coef = (double**) malloc((model->nr_class-1)*sizeof(double));
        for( i=0 ; i< model->nr_class -1 ; i++ )
                model->sv_coef[i] = (double*) malloc((model->l)*sizeof(double));
        for(i = 0; i < model->nr_class - 1; i++)
                for(j = 0; j < model->l; j++)
                        model->sv_coef[i][j] = ptr[i*(model->l)+j];
        id++;

        // SV
        {
                int sr, sc, elements;
                int num_samples;
                mwIndex *ir, *jc;
                mxArray *pprhs[1], *pplhs[1];

                // transpose SV
                pprhs[0] = rhs[id];
                if(mexCallMATLAB(1, pplhs, 1, pprhs, "transpose")) 
                {
                        svm_free_and_destroy_model(&model);
                        *msg = "cannot transpose SV matrix";
                        return NULL;
                }
                rhs[id] = pplhs[0];

                sr = (int)mxGetN(rhs[id]);
                sc = (int)mxGetM(rhs[id]);

                ptr = mxGetPr(rhs[id]);
                ir = mxGetIr(rhs[id]);
                jc = mxGetJc(rhs[id]);

                num_samples = (int)mxGetNzmax(rhs[id]);

                elements = num_samples + sr;

                model->SV = (struct svm_node **) malloc(sr * sizeof(struct svm_node *));
                x_space = (struct svm_node *)malloc(elements * sizeof(struct svm_node));

                // SV is in column
                for(i=0;i<sr;i++)
                {
                        int low = (int)jc[i], high = (int)jc[i+1];
                        int x_index = 0;
                        model->SV[i] = &x_space[low+i];
                        for(j=low;j<high;j++)
                        {
                                model->SV[i][x_index].index = (int)ir[j] + 1; 
                                model->SV[i][x_index].value = ptr[j];
                                x_index++;
                        }
                        model->SV[i][x_index].index = -1;
                }

                id++;
        }
        mxFree(rhs);

        return model;
}