/*
* Create and return a svm_csr_problem struct from a scipy.sparse.csr matrix. It is
* up to the user to free resulting structure.
*
* TODO: precomputed kernel.
*/
struct svm_csr_problem * csr_set_problem (char *values, npy_intp *n_indices,
char *indices, npy_intp *n_indptr, char *indptr, char *Y,
char *sample_weight, int kernel_type) {
struct svm_csr_problem *problem;
problem = malloc (sizeof (struct svm_csr_problem));
if (problem == NULL) return NULL;
problem->l = (int) n_indptr[0] - 1;
problem->y = (double *) Y;
problem->x = csr_to_libsvm((double *) values, (int *) indices,
(int *) indptr, problem->l);
/* should be removed once we implement weighted samples */
problem->W = (double *) sample_weight;
if (problem->x == NULL) {
free(problem);
return NULL;
}
return problem;
}
/*
* Predict using a model, where data is expected to be enconded into a csr matrix.
*/
int csr_copy_predict (npy_intp *data_size, char *data, npy_intp *index_size,
char *index, npy_intp *intptr_size, char *intptr, struct svm_csr_model *model,
char *dec_values) {
double *t = (double *) dec_values;
struct svm_csr_node **predict_nodes;
npy_intp i;
predict_nodes = csr_to_libsvm((double *) data, (int *) index,
(int *) intptr, intptr_size[0]-1);
if (predict_nodes == NULL)
return -1;
for(i=0; i < intptr_size[0] - 1; ++i) {
*t = svm_csr_predict(model, predict_nodes[i]);
free(predict_nodes[i]);
++t;
}
free(predict_nodes);
return 0;
}
int csr_copy_predict_proba (npy_intp *data_size, char *data, npy_intp *index_size,
char *index, npy_intp *intptr_size, char *intptr, struct svm_csr_model *model,
char *dec_values) {
struct svm_csr_node **predict_nodes;
npy_intp i;
int m = model->nr_class;
predict_nodes = csr_to_libsvm((double *) data, (int *) index,
(int *) intptr, intptr_size[0]-1);
if (predict_nodes == NULL)
return -1;
for(i=0; i < intptr_size[0] - 1; ++i) {
svm_csr_predict_probability(
model, predict_nodes[i], ((double *) dec_values) + i*m);
free(predict_nodes[i]);
}
free(predict_nodes);
return 0;
}
struct svm_csr_model *csr_set_model(struct svm_parameter *param, int nr_class,
char *SV_data, npy_intp *SV_indices_dims,
char *SV_indices, npy_intp *SV_indptr_dims,
char *SV_intptr,
char *sv_coef, char *rho, char *nSV, char *label,
char *probA, char *probB)
{
struct svm_csr_model *model;
double *dsv_coef = (double *) sv_coef;
int i, m;
m = nr_class * (nr_class-1)/2;
if ((model = malloc(sizeof(struct svm_csr_model))) == NULL)
goto model_error;
if ((model->nSV = malloc(nr_class * sizeof(int))) == NULL)
goto nsv_error;
if ((model->label = malloc(nr_class * sizeof(int))) == NULL)
goto label_error;
if ((model->sv_coef = malloc((nr_class-1)*sizeof(double *))) == NULL)
goto sv_coef_error;
if ((model->rho = malloc( m * sizeof(double))) == NULL)
goto rho_error;
/* in the case of precomputed kernels we do not use
dense_to_precomputed because we don't want the leading 0. As
indices start at 1 (not at 0) this will work */
model->l = (int) SV_indptr_dims[0] - 1;
model->SV = csr_to_libsvm((double *) SV_data, (int *) SV_indices,
(int *) SV_intptr, model->l);
model->nr_class = nr_class;
model->param = *param;
/*
* regression and one-class does not use nSV, label.
*/
if (param->svm_type < 2) {
memcpy(model->nSV, nSV, model->nr_class * sizeof(int));
memcpy(model->label, label, model->nr_class * sizeof(int));
}
for (i=0; i < model->nr_class-1; i++) {
/*
* We cannot squash all this mallocs in a single call since
* svm_destroy_model will free each element of the array.
*/
if ((model->sv_coef[i] = malloc((model->l) * sizeof(double))) == NULL) {
int j;
for (j=0; j<i; j++)
free(model->sv_coef[j]);
goto sv_coef_i_error;
}
memcpy(model->sv_coef[i], dsv_coef, (model->l) * sizeof(double));
dsv_coef += model->l;
}
for (i=0; i<m; ++i) {
(model->rho)[i] = -((double *) rho)[i];
}
/*
* just to avoid segfaults, these features are not wrapped but
* svm_destroy_model will try to free them.
*/
if (param->probability) {
if ((model->probA = malloc(m * sizeof(double))) == NULL)
goto probA_error;
memcpy(model->probA, probA, m * sizeof(double));
if ((model->probB = malloc(m * sizeof(double))) == NULL)
goto probB_error;
memcpy(model->probB, probB, m * sizeof(double));
} else {
model->probA = NULL;
model->probB = NULL;
}
/* We'll free SV ourselves */
model->free_sv = 0;
return model;
probB_error:
free(model->probA);
probA_error:
for (i=0; i < model->nr_class-1; i++)
free(model->sv_coef[i]);
sv_coef_i_error:
free(model->rho);
rho_error:
free(model->sv_coef);
sv_coef_error:
free(model->label);
label_error:
free(model->nSV);
nsv_error:
free(model);
model_error:
return NULL;
}
struct svm_csr_model *csr_set_model(struct svm_parameter *param, int nr_class,
char *SV_data, npy_intp *SV_indices_dims,
char *SV_indices, npy_intp *SV_indptr_dims,
char *SV_intptr,
char *sv_coef, char *rho, char *nSV, char *label,
char *probA, char *probB)
{
struct svm_csr_model *model;
double *dsv_coef = (double *) sv_coef;
int i, m;
m = nr_class * (nr_class-1)/2;
model = (struct svm_csr_model *) malloc(sizeof(struct svm_csr_model));
model->nSV = (int *) malloc(nr_class * sizeof(int));
model->label = (int *) malloc(nr_class * sizeof(int));;
model->sv_coef = (double **) malloc((nr_class-1)*sizeof(double *));
model->rho = (double *) malloc( m * sizeof(double));
/* in the case of precomputed kernels we do not use
dense_to_precomputed because we don't want the leading 0. As
indices start at 1 (not at 0) this will work */
model->SV = csr_to_libsvm((double *) SV_data, SV_indices_dims,
(int *) SV_indices, SV_indptr_dims, (int *) SV_intptr);
model->nr_class = nr_class;
model->param = *param;
model->l = (int) SV_indptr_dims[0] - 1;
/*
* regression and one-class does not use nSV, label.
* TODO: does this provoke memory leaks (we just malloc'ed them)?
*/
if (param->svm_type < 2) {
memcpy(model->nSV, nSV, model->nr_class * sizeof(int));
memcpy(model->label, label, model->nr_class * sizeof(int));
}
for (i=0; i < model->nr_class-1; i++) {
/*
* We cannot squash all this mallocs in a single call since
* svm_destroy_model will free each element of the array.
*/
model->sv_coef[i] = (double *) malloc((model->l) * sizeof(double));
memcpy(model->sv_coef[i], dsv_coef, (model->l) * sizeof(double));
dsv_coef += model->l;
}
for (i=0; i<m; ++i) {
(model->rho)[i] = -((double *) rho)[i];
}
/*
* just to avoid segfaults, these features are not wrapped but
* svm_destroy_model will try to free them.
*/
if (param->probability) {
model->probA = (double *) malloc(m * sizeof(double));
memcpy(model->probA, probA, m * sizeof(double));
model->probB = (double *) malloc(m * sizeof(double));
memcpy(model->probB, probB, m * sizeof(double));
} else {
model->probA = NULL;
model->probB = NULL;
}
/* We'll free SV ourselves */
model->free_sv = 0;
return model;
}
