mx_real_t svm_class_prob(svm_classifier_t *svm, mx_real_t *instance, int class_ind) { int i, svm_type=svm_get_svm_type(svm->model); double *prob_estimates=NULL; struct svm_node *x; mx_real_t class_prob; if (svm_type!=C_SVC && svm_type != NU_SVC) rs_error("Cannot give class probability for 1-class or regression SVM!"); x = (struct svm_node *) rs_malloc((svm->feature_dim+1)*sizeof(struct svm_node),"Feature vector representation for svm"); for (i=0;i<svm->feature_dim;i++) { x[i].index=i+1; x[i].value=instance[i]; } x[i].index=-1; _scale_instance(&x,svm->feature_dim,svm->max,svm->min); prob_estimates = (double *) rs_malloc(svm->n_classes*sizeof(double),"SVM probability estimates"); svm_predict_probability(svm->model,x,prob_estimates); class_prob = prob_estimates[class_ind]; rs_free (x); rs_free (prob_estimates); return class_prob; }
/** * @brief Predict with SVM for a given vector. * @param type Type of feature vector: Type of svm-model (1, 2, ...) * @param vec Feature vector for the SVM. * @param prob Probability of correct prediction for each class. * @return Returns the prediction label */ bool SVMPredictorSingle::process(int type, std::vector<double> &vec, std::vector<double> &prob) { int svm_type = svm_get_svm_type(model); int nr_class = svm_get_nr_class(model); double *prob_estimates = NULL; int j; if(predict_probability) { if (svm_type == NU_SVR || svm_type == EPSILON_SVR) printf("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=%g\n", svm_get_svr_probability(model)); else prob_estimates = (double *) malloc(nr_class*sizeof(double)); } // we copy now the feature vector double predict_label; for(unsigned idx = 0; idx < vec.size(); idx++) { node[idx].index = idx+1; node[idx].value = vec[idx]; node[idx+1].index = -1; } if (predict_probability && (svm_type==C_SVC || svm_type==NU_SVC)) { predict_label = svm_predict_probability(model, node, prob_estimates); for(j=0;j<nr_class;j++) prob.push_back(prob_estimates[j]); } else predict_label = svm_predict(model, node); if(predict_probability) free(prob_estimates); return predict_label; }
int PredictProb( const std::vector<T>& x, std::map<int, double>& prob ) { int dimension = scale_info_.dimension(); assert( static_cast<int>( x.size() ) == dimension ); assert( prob.empty() ); if( (libsvm_model_->param.svm_type == C_SVC || libsvm_model_->param.svm_type == NU_SVC) && libsvm_model_->probA!=NULL && libsvm_model_->probB!=NULL ) { std::vector<double> scaled_x; scale_info_.Scale( x, scaled_x ); struct svm_node* nodes; nodes = (struct svm_node *) malloc( ( dimension + 1 ) * sizeof(struct svm_node) ); GetSVMNodes( scaled_x, nodes ); int class_num = libsvm_model_->nr_class; double probs[class_num]; double predict_label = svm_predict_probability( libsvm_model_, nodes, probs ); std::vector<int> class_labels; GetClassLabels( class_labels ); for( int i = 0; i < class_num; ++i ) { prob[ class_labels[i] ] = probs[i]; } free(nodes); return static_cast<int>( predict_label ); } else { return Predict( x ); } }
static void cmd_test_list(svm_model *model, WindowFile &testFile) { const QString fmt("%1: prob { %2 , %3 } @ %4 ch %5\n"); const qint32 samples = getNumSamples(testFile); float *buf = new float[samples]; SVMNodeList nodelist(samples); double probEstim[2]; while(testFile.nextChannel()) { assert(testFile.getEventSamples() == samples); testFile.read((char*)buf, samples*sizeof(float)); nodelist.fill(buf); const char subj = (svm_predict_probability(model, nodelist, probEstim) > 0) ? 'A' : 'B'; const double t = (testFile.getEventOffset() / BytesPerSample)/ (double)SamplingRate; fputs(fmt.arg(subj) .arg(probEstim[0], 0, 'f', 4) .arg(probEstim[1], 0, 'f', 4) .arg(t, 0, 'f', 6) .arg(testFile.getChannelId()) .toAscii(), stdout); } delete[] buf; }
bool SvmClassifier::Predict(const Mat &feats, vector<int> *labels, vector<float> *probs) const { if (labels == nullptr) { return false; } int m = feats.cols; int n = feats.rows; labels->clear(); if (probs != nullptr) { probs->clear(); } // Normalize the features Mat feats_norm; Normalize(feats, &feats_norm); // Predict using SVM svm_node *x = static_cast<svm_node*>(malloc((m + 1) * sizeof(svm_node))); for (int i = 0; i < n; ++i) { for (int j = 0; j < m; ++j) { x[j].index = j + 1; x[j].value = feats_norm.at<float>(i, j); } x[m].index = -1; if (probs == nullptr) { labels->push_back(svm_predict(svm_model_, x)); } else { double *prob = static_cast<double*>( malloc(svm_model_->nr_class * sizeof(double))); int label = svm_predict_probability(svm_model_, x, prob); labels->push_back(label); int idx = 0; for (int k = 0; k < svm_model_->nr_class; ++k) { if (label == svm_model_->label[k]) { idx = k; break; } } probs->push_back(prob[idx]); delete prob; } } free(x); return true; }
float jpcnn_predict(void* predictorHandle, float* predictions, int predictionsLength) { SPredictorInfo* predictorInfo = (SPredictorInfo*)(predictorHandle); struct svm_model* model = predictorInfo->model; struct svm_node* nodes = create_node_list(predictions, predictionsLength); double probabilityEstimates[2]; svm_predict_probability(model, nodes, probabilityEstimates); const double predictionValue = probabilityEstimates[0]; destroy_node_list(nodes); return predictionValue; }
int gcm::patchRun(vector<SLR_ST_Skeleton> vSkeletonData, vector<Mat> vDepthData, vector<IplImage*> vColorData, int *rankIndex, double *rankScore) { int kernelFeatureDim = NClass*NTrainSample; //clock_t startT=clock(); oriData2Feature(vSkeletonData, vDepthData, vColorData); //cout<<"=======Time========="<<clock()-startT<<endl; gcmSubspace(); x[0].index = 0; for (int j=0; j<kernelFeatureDim; j++) { subMatrix(subFeaAll_model, subFea1, 0, featureDim, j*subSpaceDim, subSpaceDim); x[j+1].value = myGcmKernel.Frobenius(subFea1, gcm_subspace, featureDim, subSpaceDim); x[j+1].index=j+1; } x[kernelFeatureDim+1].index=-1; //int testID = svm_predict_probability(myModel, x, prob_estimates); int testID_noPro = svm_predict(myModel, x); int testID = svm_predict_probability(myModel_candi, x, prob_estimates); //Sort and get the former 5 ranks. vector<scoreAndIndex> rank; for (int i=0; i<myModel->nr_class; i++) { scoreAndIndex temp; temp.index = myModel->label[i]; temp.score = prob_estimates[i]; rank.push_back(temp); } sort(rank.begin(),rank.end(),comp); rankIndex[0] = testID_noPro; rankScore[0] = 1.0; int candiN = 0; //for (int i=1; i<5; i++) int seqCandiN = 1; while(seqCandiN<5) { if (rank[candiN].index == testID_noPro) { candiN++; continue; } rankIndex[seqCandiN] = rank[candiN].index; rankScore[seqCandiN] = rank[candiN].score; candiN++; seqCandiN++; } releaseResource(); return rankIndex[0]; }
bool SVM::predictSVM(VectorDouble &inputVector,double &maxProbability, VectorDouble &probabilites){ if( !trained || param.probability == 0 || inputVector.size() != numInputDimensions ) return false; double *prob_estimates = NULL; svm_node *x = NULL; //Setup the memory for the probability estimates prob_estimates = new double[ model->nr_class ]; //Copy the input data into the SVM format x = new svm_node[numInputDimensions+1]; for(UINT j=0; j<numInputDimensions; j++){ x[j].index = (int)j+1; x[j].value = inputVector[j]; } //The last value in the input vector must be set to -1 x[numInputDimensions].index = -1; x[numInputDimensions].value = 0; //Scale the input data if required if( useScaling ){ for(UINT j=0; j<numInputDimensions; j++) x[j].value = scale(x[j].value,ranges[j].minValue,ranges[j].maxValue,SVM_MIN_SCALE_RANGE,SVM_MAX_SCALE_RANGE); } //Perform the SVM prediction double predict_label = svm_predict_probability(model,x,prob_estimates); predictedClassLabel = 0; maxProbability = 0; probabilites.resize(model->nr_class); for(int k=0; k<model->nr_class; k++){ if( maxProbability < prob_estimates[k] ){ maxProbability = prob_estimates[k]; predictedClassLabel = k+1; maxLikelihood = maxProbability; } probabilites[k] = prob_estimates[k]; } if( !useNullRejection ) predictedClassLabel = (UINT)predict_label; else{ if( maxProbability >= classificationThreshold ){ predictedClassLabel = (UINT)predict_label; }else predictedClassLabel = GRT_DEFAULT_NULL_CLASS_LABEL; } //Clean up the memory delete[] prob_estimates; delete[] x; return true; }
void SVMPredict::predict_prob(const struct svm_model* m, const struct svm_node* x, double* label, double* prob_estimate) { //v8::HandleScope scope(GetIsolate()); #if defined(PROCESS_DEBUG) log("is called"); //CW_ASSERT(m==NULL); //CW_ASSERT(x==NULL); #endif *label = svm_predict_probability(m,x,prob_estimate); }
int predict(double **values, int **indices, int rowNum, int *arrayNcol, int *labels, double **prob_estimates, int isProb) { int svm_type=svm_get_svm_type(model); int nr_class=svm_get_nr_class(model); int j; LOGD("isProb:%d", isProb); if(isProb) { if (svm_type==NU_SVR || svm_type==EPSILON_SVR) LOGD("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=%g\n",svm_get_svr_probability(model)); else { int *labels=(int *) malloc(nr_class*sizeof(int)); svm_get_labels(model,labels); // fprintf(output,"labels"); // for(j=0;j<nr_class;j++) // fprintf(output," %d",labels[j]); // fprintf(output,"\n"); // free(labels); } } // each record will receive // a predicted label and a [nClass]-D probability estimate array for (int i = 0; i < rowNum; i++) { int nCol = arrayNcol[i]; double target_label = 0; int predict_label=0; x = (struct svm_node *) realloc(x,(nCol+1)*sizeof(struct svm_node)); for (int j = 0; j < nCol; j++) { x[j].index = indices[i][j]; x[j].value = values[i][j]; } x[nCol].index = -1; // Probability prediction if (isProb && (svm_type==C_SVC || svm_type==NU_SVC)) { // prob_estimate[rowNum][nClass] labels[i] = svm_predict_probability(model,x,prob_estimates[i]); } // without probability else { labels[i] = svm_predict(model,x); } } // For return 0; }
void SvmClassiUser(float* feature,int &lable) { //double out; InitData(feature); int feature_dimension=5; double* outPro=NULL; //ReScaleFeatures(float* features,int feature_dimension,float* feature_min,float* feature_max); svm_node* nodes=(svm_node*)malloc((feature_dimension+1)*sizeof(svm_node)); GenerateSvmNode(feature,feature_dimension,nodes); lable=svm_predict_probability(svmModel_userFeel,nodes,outPro); //printf("%d\n",lable); free(nodes); }
double SVM::classify(struct svm_node *data, char* filename_model) { double predict_label; double *prob_estimates = NULL; int svm_type; int nr_class; // load feature file only once if(!this->_bFeatureFileLoaded) { if((this->_svmModel = svm_load_model(filename_model))==0) { printf("can't open model file %s\n",filename_model); return -99; } this->_bFeatureFileLoaded = true; } svm_type = svm_get_svm_type(this->_svmModel); nr_class = svm_get_nr_class(this->_svmModel); prob_estimates = (double *) malloc(nr_class*sizeof(double)); if (svm_type==C_SVC || svm_type==NU_SVC) { predict_label = svm_predict_probability(this->_svmModel,data,prob_estimates); // printf("%g",predict_label); //for(int k=0; k < nr_class; k++) //printf(" %g",prob_estimates[k]); //printf("\n"); } else { predict_label = svm_predict(this->_svmModel, data); printf("%g\n",predict_label); } free(data); free(prob_estimates); return predict_label; }
int predict(float **values, int **indices, int rowNum, int colNum, int *labels, double *prob_estimates, int isProb) { int svm_type=svm_get_svm_type(model); int nr_class=svm_get_nr_class(model); int j; if(isProb) { if (svm_type==NU_SVR || svm_type==EPSILON_SVR) LOGD("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=%g\n",svm_get_svr_probability(model)); else { int *labels=(int *) malloc(nr_class*sizeof(int)); svm_get_labels(model,labels); // fprintf(output,"labels"); // for(j=0;j<nr_class;j++) // fprintf(output," %d",labels[j]); // fprintf(output,"\n"); // free(labels); } } for (int i = 0; i < rowNum; i++) { double target_label, predict_label=0; x = (struct svm_node *) realloc(x,(colNum+1)*sizeof(struct svm_node)); for (int j = 0; j < colNum; j++) { x[j].index = indices[i][j]; x[j].value = values[i][j]; } x[colNum].index = -1; // Probability prediction if (isProb && (svm_type==C_SVC || svm_type==NU_SVC)) { predict_label = svm_predict_probability(model,x,prob_estimates); labels[0]=predict_label; } else { labels[i] = svm_predict(model,x); } } // For return 0; }
int copy_predict_proba(char *predict, struct svm_model *model, npy_intp *predict_dims, char *dec_values) { npy_intp i, n, m; struct svm_node *predict_nodes; n = predict_dims[0]; m = (npy_intp) model->nr_class; predict_nodes = dense_to_libsvm((double *) predict, predict_dims); if (predict_nodes == NULL) return -1; for(i=0; i<n; ++i) { svm_predict_probability(model, &predict_nodes[i], ((double *) dec_values) + i*m); } free(predict_nodes); return 0; }
int main(){ auto test_data = read_data("1_3"); svm_model* model = svm_load_model("1_3_b_model"); int nr_class = svm_get_nr_class(model); for (auto svmData : test_data){ svm_node* nodes = AssignSVMNode(svmData); double* probEstimates = new double[nr_class]; svm_predict_probability(model, nodes, probEstimates); for (int i = 0; i < nr_class; ++i){ std::cout<<i<<":"<<probEstimates[i]<<" "; } std::cout<<std::endl; } getchar(); return 0; }
bool CmySvmArth::Sim(double* res , int& len) { if(model==NULL||res==NULL) return false; int svm_type=svm_get_svm_type(model); int nr_class=svm_get_nr_class(model); double *prob_estimates=NULL; len = m_nSimDataLen; if (predict_probability && (svm_type==C_SVC || svm_type==NU_SVC)) { prob_estimates = new double[nr_class]; *res = svm_predict_probability(model,m_pTestdata,prob_estimates); delete prob_estimates; } else { *res = svm_predict(model,m_pTestdata); } return true; }
void predict_strand_MEANMFE_CONSMFE(double *prob, double *decValue, double deltaMeanMFE, double deltaConsMFE, int n_seq, double id) { struct svm_node node[5]; double value=0; node[0].index = 1; node[0].value = deltaMeanMFE; node[1].index = 2; node[1].value = deltaConsMFE; node[2].index = 3; node[2].value = (double)n_seq; node[3].index = 4; node[3].value = id; node[4].index = -1; scale_strand_decision_node((struct svm_node*)&node); svm_predict_values(strand_model,node,&value); *decValue=value; svm_predict_probability(strand_model,node,&value); // ATTENTION: If model parameters are not set correctly, then value is not set, type of SVM need to // to be C_SVC or nu_SVC! *prob=value; return; }
int SVMPredict2(struct svm_model* model, float *descript_vector, double *prob_est, int size)// prob_est is a pointer to array { int correct = 0; int total = 0; double error = 0; double sump = 0, sumt = 0, sumpp = 0, sumtt = 0, sumpt = 0; int svm_type = svm_get_svm_type(model); int nr_class = svm_get_nr_class(model); double *prob_estimates = NULL; int j; int i = 0; double target_label, predict_label; char *idx, *val, *label, *endptr; int inst_max_index = -1; // strtol gives 0 if wrong format, and precomputed kernel has <index> start from 0 int n = 1; while (n < size) n *= 2; struct svm_node* x = (struct svm_node *) malloc(n*sizeof(struct svm_node)); for (int i = 0; i < size; i++) { x[i].index = i + 1; x[i].value = descript_vector[i]; } x[size].index = -1; if (prob_est != NULL) predict_label = svm_predict_probability(model, x, prob_est); else predict_label = svm_predict(model, x); if (prob_est != NULL) *prob_est = -1; free(x); return predict_label; }
double HandTranslating::predictTestImage() { double predict_label; printf("labels"); for(int j = 0;j < nr_class;j++) { printf(" %d",labels[j]); } printf("\n"); if (svm_type==C_SVC || svm_type==NU_SVC) { predict_label = svm_predict_probability(model,nodeTest,prob_estimates); printf("%g",predict_label); for(int j = 0;j < nr_class;j++) { printf(" %g",prob_estimates[j]); } printf("\n"); } return predict_label; }
Label PredictModel::CPredictModel::predictProbability(const Array<std::pair<int32, double>>& vector, Array<double>& probabilities) const { if (!m_model) { probabilities.clear(); return Math::NaN; } Array<svm_node> node(vector.size() + 1); for (int32 i = 0; i < static_cast<int32>(vector.size()); ++i) { node[i].index = vector[i].first; node[i].value = vector[i].second; } node.back().index = -1; probabilities.resize(m_model->nr_class, 3); return svm_predict_probability(m_model, node.data(), probabilities.data()); }
int cLibsvmLiveSink::myTick(long long t) { if (model == NULL) return 0; SMILE_DBG(4,"tick # %i, classifiy value vector using LibSVM (lag=%i):",t,lag); cVector *vec= reader->getFrameRel(lag); //new cVector(nValues+1); if (vec == NULL) return 0; // else reader->nextFrame(); struct svm_node *x = NULL; int i = 0; double v; // need one more for index = -1 long Nft = Nsel; if (Nft <= 0) Nft = vec->N; if (fselType) { if ((outputSelIdx.enabled == NULL)&&(outputSelStr.names != NULL)) { buildEnabledSelFromNames(vec->N, vec->fmeta); } else if (outputSelIdx.enabled == NULL) Nft = vec->N; } // TODO: fselection by names... // TODO: compute Nsel in loadSelection x = (struct svm_node *) malloc( (Nft + 1) * sizeof(struct svm_node)); int j = 0; for (i=0; i<vec->N; i++) { if ((outputSelIdx.enabled == NULL)||(Nsel<=0)) { x[i].index = i+1; // FIXME!!! +1 is ok??? (no!?) x[i].value = vec->dataF[i]; } else { if (outputSelIdx.enabled[i]) { x[j].index = j+1; // FIXME!!! +1 is ok??? (no!?) x[j].value = vec->dataF[i]; j++; } } } if ((outputSelIdx.enabled == NULL)||(Nsel<=0)) { x[i].index = -1; x[i].value = 0.0; } else { x[j].index = -1; x[j].value = 0.0; } svm_apply_scale(scale,x); /* for (i=0; i<vec->n; i++) { printf("%i:%f ",i,x[i].value); } printf("\n"); */ long vi = vec->tmeta->vIdx; double tm = vec->tmeta->smileTime; double dur = vec->tmeta->lengthSec; if ( (predictProbability) && (svmType==C_SVC || svmType==NU_SVC) ) { v = svm_predict_probability(model,x,probEstimates); processResult(t, vi, tm, v, probEstimates, nClasses, dur); // printf("%g",v); // for(j=0;j<nr_class;j++) // printf(" %g",prob_estimates[j]); // printf("\n"); } else { v = svm_predict(model,x); processResult(t, vi, tm, v, NULL, nClasses, dur); // result = v; // printf("%g\n",v); } free(x); /* if (svm_type==NU_SVR || svm_type==EPSILON_SVR) { printf("Mean squared error = %g (regression)\n",error/total); printf("Squared correlation coefficient = %g (regression)\n", ((total*sumvy-sumv*sumy)*(total*sumvy-sumv*sumy))/ ((total*sumvv-sumv*sumv)*(total*sumyy-sumy*sumy)) ); } else printf("Accuracy = %g%% (%d/%d) (classification)\n", (double)correct/total*100,correct,total); */ // tick success return 1; }
JNIEXPORT jint JNICALL Java_LibSVMTest_doClassificationNative (JNIEnv *env, jobject obj, jobjectArray valuesArr, jobjectArray indicesArr, jint isProb, jintArray labelsArr, jdoubleArray probsArr) { int *labels = env->GetIntArrayElements(labelsArr, NULL); // initiate the arrays int nRow = env->GetArrayLength(valuesArr); double **probs = (double **) calloc(nRow, sizeof(double *)); jfloatArray vrows = (jfloatArray) env->GetObjectArrayElement(valuesArr, 0); jintArray irows = (jintArray) env->GetObjectArrayElement(indicesArr, 0); jfloat *velement = env->GetFloatArrayElements(vrows, NULL); jint *ielement = env->GetIntArrayElements(irows, NULL); int colNum = env->GetArrayLength(vrows); probs[0] = env->GetDoubleArrayElements(probsArr, NULL); if(isProb) { if(svm_check_probability_model(model_F)==0) { fprintf(stderr, "Model does not support probabiliy estimates\n"); exit(1); } } else { if(svm_check_probability_model(model_F)!=0) fprintf(stderr, "Model supports probability estimates, but disabled in prediction.\n"); } if(isProb) { if (svm_type==NU_SVR || svm_type==EPSILON_SVR) fprintf(stderr, "Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=%g\n",svm_get_svr_probability(model_F)); else { int *labels=(int *) malloc(nr_class*sizeof(int)); svm_get_labels(model_F,labels); } } double predict_label=0; struct svm_node *x = (struct svm_node *) malloc(64*sizeof(struct svm_node)); x = (struct svm_node *) realloc(x, (colNum+1)*sizeof(struct svm_node)); for (int j = 0; j < colNum; j++) { x[j].index = velement[j]; x[j].value = ielement[j]; } x[colNum].index = -1; // Probability prediction if (isProb && (svm_type==C_SVC || svm_type==NU_SVC)) { predict_label = svm_predict_probability(model_F,x,*probs); labels[0]=predict_label; } else { labels[0] = svm_predict(model_F,x);} env->ReleaseFloatArrayElements(vrows, velement, JNI_ABORT); env->ReleaseIntArrayElements(irows, ielement, JNI_ABORT); //added for fixing : JNI ERROR (app bug): local reference table overflow (max=512) env->DeleteLocalRef(vrows); env->DeleteLocalRef(irows); // release the one-D arrays and strings env->ReleaseIntArrayElements(labelsArr, labels, 0); //added for fixing : JNI ERROR (app bug): local reference table overflow (max=512) env->DeleteLocalRef(labelsArr); free(x); return 0; }
vector<double> classifyObjects(vector<MatDict > features) { // Load the SVM svm_model *model = nullptr; Mat train_max; Mat train_min; if (DEBUG) { *model = *svm_load_model(MODEL_PATH); train_max = loadCSV(TRAIN_MAX_PATH); train_min = loadCSV(TRAIN_MIN_PATH); } else { #if !DEBUG CFURLRef model_url = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("model_out"), CFSTR("txt"), NULL); CFURLRef max_url = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("train_max"), CFSTR("csv"), NULL); CFURLRef min_url = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("train_min"), CFSTR("csv"), NULL); char model_path[1024]; char max_path[1024]; char min_path[1024]; CFURLGetFileSystemRepresentation(model_url, true, model_path, sizeof(model_path)); CFURLGetFileSystemRepresentation(max_url, true, max_path, sizeof(max_path)); CFURLGetFileSystemRepresentation(min_url, true, min_path, sizeof(min_path)); CFRelease(model_url); CFRelease(max_url); CFRelease(min_url); *model = *svm_load_model(model_path); train_max = loadCSV(max_path); train_min = loadCSV(min_path); #endif } // Combine the features cv::Mat featuresMatrix = cv::Mat((int)features.size(), 22, CV_64F); vector<MatDict >::const_iterator it = features.begin(); int row = 0; for (; it != features.end(); it++) { MatDict patch = *it; cv::Mat geom = patch.find("geom")->second; cv::Mat phi = patch.find("phi")->second; int index = 0; for (int i = 0; i < phi.rows; i++) { double val = phi.at<double>(i, 0); featuresMatrix.at<double>(row, index) = val; index++; } for (int i = 0; i < geom.rows; i++) { cv::Mat rowMat = patch.find("row")->second; cv::Mat colMat = patch.find("col")->second; float geom_val = geom.at<float>(i, 0); featuresMatrix.at<double>(row, index) = (double) geom_val; index++; } row++; } Debug::print(featuresMatrix, "xtest.txt"); // minmax normalization of features cv::Mat maxMatrix = repMat(train_max, featuresMatrix.rows); cv::Mat minMatrix = repMat(train_min, featuresMatrix.rows); cv::Mat testMatrix = cv::Mat(featuresMatrix.rows, featuresMatrix.cols, featuresMatrix.type()); cv::Mat numerator = cv::Mat(featuresMatrix.rows, featuresMatrix.cols, featuresMatrix.type()); cv::Mat denominator = cv::Mat(featuresMatrix.rows, featuresMatrix.cols, featuresMatrix.type()); cv::subtract(featuresMatrix, minMatrix, numerator); cv::subtract(maxMatrix, minMatrix, denominator); cv::divide(numerator, denominator, testMatrix); Debug::print(numerator, "numerator.txt"); Debug::print(testMatrix, "xtest_final.txt"); //testMatrix = Debug::loadMatrix("xtest_final.txt", 120, 22, CV_64F); // Classify objects and get probabilities vector<double> prob_results; for (int i = 0; i < testMatrix.rows; i++) { svm_node *node = new svm_node[testMatrix.cols + 2]; for (int j = 0; j < testMatrix.cols; j++) { double d = testMatrix.at<double>(i, j); node[j].index = j+1; node[j].value = d; } node[testMatrix.cols].index = -1; node[testMatrix.cols].value = 0; double *probabilities = new double[2]; svm_predict_probability(model, node, probabilities); prob_results.push_back(probabilities[0]); } cout << "Finished classifying features" << endl; Debug::printVector(prob_results, "dvtest.txt"); return prob_results; }
void svmpredict (int *decisionvalues, int *probability, double *v, int *r, int *c, int *rowindex, int *colindex, double *coefs, double *rho, int *compprob, double *probA, double *probB, int *nclasses, int *totnSV, int *labels, int *nSV, int *sparsemodel, int *svm_type, int *kernel_type, int *degree, double *gamma, double *coef0, double *x, int *xr, int *xrowindex, int *xcolindex, int *sparsex, double *ret, double *dec, double *prob) { struct svm_model m; struct svm_node ** train; int i; /* set up model */ m.l = *totnSV; m.nr_class = *nclasses; m.sv_coef = (double **) malloc (m.nr_class * sizeof(double*)); for (i = 0; i < m.nr_class - 1; i++) { m.sv_coef[i] = (double *) malloc (m.l * sizeof (double)); memcpy (m.sv_coef[i], coefs + i*m.l, m.l * sizeof (double)); } if (*sparsemodel > 0) m.SV = transsparse(v, *r, rowindex, colindex); else m.SV = sparsify(v, *r, *c); m.rho = rho; m.probA = probA; m.probB = probB; m.label = labels; m.nSV = nSV; /* set up parameter */ m.param.svm_type = *svm_type; m.param.kernel_type = *kernel_type; m.param.degree = *degree; m.param.gamma = *gamma; m.param.coef0 = *coef0; m.param.probability = *compprob; m.free_sv = 1; /* create sparse training matrix */ if (*sparsex > 0) train = transsparse(x, *xr, xrowindex, xcolindex); else train = sparsify(x, *xr, *c); /* call svm-predict-function for each x-row, possibly using probability estimator, if requested */ if (*probability && svm_check_probability_model(&m)) { for (i = 0; i < *xr; i++) ret[i] = svm_predict_probability(&m, train[i], prob + i * *nclasses); } else { for (i = 0; i < *xr; i++) ret[i] = svm_predict(&m, train[i]); } /* optionally, compute decision values */ if (*decisionvalues) for (i = 0; i < *xr; i++) svm_predict_values(&m, train[i], dec + i * *nclasses * (*nclasses - 1) / 2); /* clean up memory */ for (i = 0; i < *xr; i++) free (train[i]); free (train); for (i = 0; i < *r; i++) free (m.SV[i]); free (m.SV); for (i = 0; i < m.nr_class - 1; i++) free(m.sv_coef[i]); free(m.sv_coef); }
void predict(FILE *input, FILE *output) { int correct = 0; int total = 0; double error = 0; double sump = 0, sumt = 0, sumpp = 0, sumtt = 0, sumpt = 0; int svm_type=svm_get_svm_type(model); int nr_class=svm_get_nr_class(model); double *prob_estimates=NULL; int j; if(predict_probability) { if (svm_type==NU_SVR || svm_type==EPSILON_SVR) printf("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=%g\n",svm_get_svr_probability(model)); else { int *labels=(int *) malloc(nr_class*sizeof(int)); svm_get_labels(model,labels); prob_estimates = (double *) malloc(nr_class*sizeof(double)); fprintf(output,"labels"); for(j=0;j<nr_class;j++) fprintf(output," %d",labels[j]); fprintf(output,"\n"); free(labels); } } max_line_len = 1024; line = (char *)malloc(max_line_len*sizeof(char)); while(readline(input) != NULL) { int i = 0; double target_label, predict_label; char *idx, *val, *label, *endptr; int inst_max_index = -1; // strtol gives 0 if wrong format, and precomputed kernel has <index> start from 0 label = strtok(line," \t"); target_label = strtod(label,&endptr); if(endptr == label) exit_input_error(total+1); while(1) { if(i>=max_nr_attr-1) // need one more for index = -1 { max_nr_attr *= 2; x = (struct svm_node *) realloc(x,max_nr_attr*sizeof(struct svm_node)); } idx = strtok(NULL,":"); val = strtok(NULL," \t"); if(val == NULL) break; errno = 0; x[i].index = (int) strtol(idx,&endptr,10); if(endptr == idx || errno != 0 || *endptr != '\0' || x[i].index <= inst_max_index) exit_input_error(total+1); else inst_max_index = x[i].index; errno = 0; x[i].value = strtod(val,&endptr); if(endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr))) exit_input_error(total+1); ++i; } x[i].index = -1; if (predict_probability && (svm_type==C_SVC || svm_type==NU_SVC)) { predict_label = svm_predict_probability(model,x,prob_estimates); fprintf(output,"%g",predict_label); for(j=0;j<nr_class;j++) fprintf(output," %g",prob_estimates[j]); fprintf(output,"\n"); } else { predict_label = svm_predict(model,x); fprintf(output,"%g\n",predict_label); } if(predict_label == target_label) ++correct; error += (predict_label-target_label)*(predict_label-target_label); sump += predict_label; sumt += target_label; sumpp += predict_label*predict_label; sumtt += target_label*target_label; sumpt += predict_label*target_label; ++total; } if (svm_type==NU_SVR || svm_type==EPSILON_SVR) { printf("Mean squared error = %g (regression)\n",error/total); printf("Squared correlation coefficient = %g (regression)\n", ((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/ ((total*sumpp-sump*sump)*(total*sumtt-sumt*sumt)) ); } else printf("Accuracy = %g%% (%d/%d) (classification)\n", (double)correct/total*100,correct,total); if(predict_probability) free(prob_estimates); }
void predict(FILE *input, FILE *output, FILE *output_w2, FILE *output_prob,int predict_probability, FILE *addr, int Ncol, int Nlig, long Npolar) { int svm_type=svm_get_svm_type(model); int nr_class=svm_get_nr_class(model); double *prob_estimates=NULL; int i,j,k,l,num_block,p,n,count; int Nband[Npolar]; long n_addr = 0,m=0, n_total_band, offset=0; long max_num_pixel, num_rest_pixel, n_img_pixel = (long)Ncol * (long)Nlig; float buff_float, zero = 0; float **V_pol_rest, **V_pol_block, *v_pol_buff; long int *tab_addr, buff_long_int; float *output_label; double *w2_predict; float **w2_predict_out, *mean_dist, *max_prob, **prob_estimates_out; max_num_pixel = (long)floor(memory_pixel /((long)4 * Npolar)); for(i=0; i< n_img_pixel; i++){// We initiaite the output classification file with '0' value fwrite(&zero, sizeof(float), 1, output); } rewind(output); /* for(i=0; i< n_img_pixel*(nr_class*(nr_class-1)/2 +1) ; i++){// We initiaite the output classification file with '0' value fwrite(&zero, sizeof(float), 1, output_w2); } rewind(output_w2); */ if(predict_probability) { printf("Predict prob!!!!\n"); for(i=0; i< n_img_pixel*(nr_class + 1) ; i++){// We initiaite the output classification file with '0' value fwrite(&zero, sizeof(float), 1, output_prob); } rewind(output_prob); if (svm_type==NU_SVR || svm_type==EPSILON_SVR) printf("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=%g\n",svm_get_svr_probability(model)); else { int *labels=(int *) malloc(nr_class*sizeof(int)); svm_get_labels(model,labels); prob_estimates = (double *) malloc(nr_class*sizeof(double)); //fprintf(output,"labels"); //for(j=0;j<nr_class;j++) // printf(" %d\n",labels[j]); //fprintf(output," %d",labels[j]); //fprintf(output,"\n"); free(labels); } } while(fread(&buff_long_int, sizeof(long int), 1, addr)!=0){ // We read the addr file to know the number of pixel to be classified n_addr++; } n_addr = n_addr - Npolar; rewind(addr); tab_addr = (long int *) malloc((long int) (n_addr) * sizeof(long int)); for(i=0; i<Npolar;i++){ fread(&buff_long_int, sizeof(long int), 1, addr); Nband[i] = (int)buff_long_int; } i=0; while(fread(&tab_addr[i], sizeof(long int), 1, addr)!=0){ // We read the addr of each classified pixel //hde //printf("tab_addr[%d]:%d\n",i,tab_addr[i]); i++; } //hde int min,max; min=tab_addr[0]; max=min; for (i=0;i<n_addr;i++) { if (tab_addr[i]>max) {max=tab_addr[i];} if (tab_addr[i]<min) {min=tab_addr[i];} } printf("min:%d; max:%d\n",min,max); // fin HDE // We compute the necessary number of block and remaining pixel num_block = (int)floor(n_addr /max_num_pixel); num_rest_pixel = n_addr - num_block * max_num_pixel; printf("num_block: %i\n",num_block); /////////////////////////////////////////////////Ajouter boucle de lecture des float input pour ensuite calculer le //nb de bande total initial pour faire une lecutre par bloc de bande puis extraire celle qui sont interessante while(fread(&buff_float, sizeof(float), 1, input)!=0){ m++; } rewind(input); if(num_block > 0){//Loop on the block V_pol_block = matrix_float((int)max_num_pixel,(int)Npolar); output_label = vector_float((int)max_num_pixel); // mean_dist = vector_float((int)max_num_pixel); // w2_predict_out = matrix_float((int)max_num_pixel,nr_class*(nr_class-1)/2); prob_estimates_out = matrix_float((int)max_num_pixel,nr_class); max_prob = vector_float((int)max_num_pixel); for (i=0; i<num_block; i++){ // blocs pour l'optimisation accès disque for (j=0; j< max_num_pixel; j++){ for (k=0; k<Npolar; k++){ // pointe sur le pixel col,lig, k(bande), selon la bande offset = (long)(sizeof(float)) * (Nband[k] * n_img_pixel + tab_addr[i*max_num_pixel + j]); fseek(input, offset, SEEK_SET); //place le pointeur à l'offset calculé avant qui s'appelle offset ! fread(&V_pol_block[j][k], sizeof(float), 1, input); } } for (j=0; j< max_num_pixel; j++){ for (k=0; k<Npolar; k++){ if(k>=max_nr_attr-1) // need one more for index = -1 { max_nr_attr *= 2; x = (struct svm_node *) realloc(x,max_nr_attr*sizeof(struct svm_node)); } x[k].index = k+1; x[k].value = scale(k, (double)V_pol_block[j][k]); } x[k].index = -1; double predict_label; if (predict_probability && (svm_type==C_SVC || svm_type==NU_SVC)) { //printf("Predict prob if block!!!!\n"); predict_label = svm_predict_probability(model,x,prob_estimates); w2_predict = svm_w2(model,x); output_label[j] = (float)predict_label; // mean_dist[j] = 0.; count = 0; l=0; max_prob[j] = 0.; for(p=0;p<nr_class;p++){ for(n=p+1;n<nr_class;n++){ // w2_predict_out[j][l] =(float)w2_predict[l]; // printf("w2_predict[%i] : %g\n",w2_predict[l]); if(p+1 == output_label[j] || n+1 == output_label[j]){ // mean_dist[j] = mean_dist[j] + w2_predict_out[j][l]; count = count + 1; } l++; } prob_estimates_out[j][p] = (float)prob_estimates[p]; if(max_prob[j] < prob_estimates_out[j][p] ){ max_prob[j] = prob_estimates_out[j][p]; } } // mean_dist[j] = mean_dist[j] / (float)count; } else { predict_label = svm_predict(model,x); w2_predict = svm_w2(model,x); output_label[j] = (float)predict_label; // mean_dist[j] = 0.; count = 0; l=0; for(p=0;p<nr_class;p++){ for(n=p+1;n<nr_class;n++){ // w2_predict_out[j][l] =(float)w2_predict[l]; if(p+1 == output_label[j] || n+1 == output_label[j]){ // mean_dist[j] = mean_dist[j] + w2_predict_out[j][l]; count = count + 1; } l++; } } // mean_dist[j] = mean_dist[j] / (float)count; } }/* pixels block */ for (j=0; j< max_num_pixel; j++){ // On ecrit le fichier de classif offset = (long)(sizeof(float)) * tab_addr[i*max_num_pixel + j]; fseek (output, offset, SEEK_SET); fwrite(&output_label[j], sizeof(float), 1, output); } /* for (l=0; l< nr_class*(nr_class-1)/2; l++){ // On ecrit les cartes de distances for (j=0; j< max_num_pixel; j++){ offset = (long)(sizeof(float)) * tab_addr[i*max_num_pixel + j]; fseek(output_w2, offset + n_img_pixel * sizeof(float) * l, SEEK_SET); fwrite(&w2_predict_out[j][l], sizeof(float), 1, output_w2); } } for (j=0; j< max_num_pixel; j++){ // On ecrit la distance moyenne offset = (long)(sizeof(float)) * tab_addr[i*max_num_pixel + j]; fseek(output_w2, offset + n_img_pixel * sizeof(float) * (nr_class*(nr_class-1)/2), SEEK_SET);// on ecrit la distance moyenne parmi les classif bianaire renvoyant le label final fwrite(&mean_dist[j], sizeof(float), 1, output_w2); } */ if(predict_probability){ //printf("Predict prob fin if block ecriture!!!!\n"); for (l=0; l< nr_class; l++){ // On ecrit les cartes de probabilité for (j=0; j< max_num_pixel; j++){ offset = (long)(sizeof(float)) * tab_addr[i*max_num_pixel + j]; fseek(output_prob, offset + n_img_pixel * sizeof(float) * l, SEEK_SET); fwrite(&prob_estimates_out[j][l], sizeof(float), 1, output_prob); } } for (j=0; j< max_num_pixel; j++){ offset = (long)(sizeof(float)) * tab_addr[i*max_num_pixel + j]; fseek(output_prob, offset + n_img_pixel * sizeof(float) * nr_class, SEEK_SET); fwrite(&max_prob[j], sizeof(float), 1, output_prob); } } }/* Loop over the blocks*/ free_matrix_float(V_pol_block, max_num_pixel); // free_matrix_float(w2_predict_out, max_num_pixel); free_matrix_float(prob_estimates_out, max_num_pixel); free_vector_float(output_label); // free_vector_float(mean_dist); free(w2_predict); free_vector_float(max_prob); printf("FREE block: %i\n",num_block); }else{ printf("PAS DE BLOCK\n"); } if(num_rest_pixel > 0){// Loop on the remaining pixel V_pol_rest = matrix_float((int)num_rest_pixel,(int)Npolar);/* Vector of polarimetrics indicators for the remaining pixel */ output_label = vector_float((int)num_rest_pixel); // w2_predict_out = matrix_float((int)num_rest_pixel,nr_class*(nr_class-1)/2); // mean_dist = vector_float((int)num_rest_pixel); prob_estimates_out = matrix_float((int)num_rest_pixel,nr_class); max_prob = vector_float((int)max_num_pixel); for (j=0; j< num_rest_pixel;j++){ for (k=0; k<Npolar; k++){ offset = (long)(sizeof(float)) * (Nband[k] * n_img_pixel + tab_addr[num_block*max_num_pixel + j]); fseek (input, offset , SEEK_SET); fread(&V_pol_rest[j][k], sizeof(float), 1, input); //hde //printf("valeur pixel a adresse %d et pour bande %d: %d\n", tab_addr[num_block*max_num_pixel + j],k,V_pol_rest[j][k]); } } for (j=0; j< num_rest_pixel;j++){ for (k=0; k<Npolar; k++){ if(k>=max_nr_attr-1) // need one more for index = -1 { max_nr_attr *= 2; x = (struct svm_node *) realloc(x,max_nr_attr*sizeof(struct svm_node)); } x[k].index = k+1; x[k].value = scale(k, (double)V_pol_rest[j][k]); } x[k].index = -1; double predict_label; if (predict_probability && (svm_type==C_SVC || svm_type==NU_SVC)) { //printf("Predict prob if fin apres block!!!!\n"); predict_label = svm_predict_probability(model,x,prob_estimates); w2_predict = svm_w2(model,x); output_label[j] = (float)predict_label; // mean_dist[j] = 0.; count = 0; l=0; max_prob[j] = 0.; for(p=0;p<nr_class;p++){ for(n=p+1;n<nr_class;n++){ // w2_predict_out[j][l] =(float)w2_predict[l]; // printf("w2_predict[%i] : %g\n",l,w2_predict[l]); // printf("w2_predict_out[%i][%i] : %g\n",j,l,w2_predict_out[j][l]); if(p+1 == output_label[j] || n+1 == output_label[j]){ // mean_dist[j] = mean_dist[j] + w2_predict_out[j][l]; count = count + 1; } l++; } prob_estimates_out[j][p] = (float)prob_estimates[p]; if(max_prob[j] < prob_estimates_out[j][p] ){ max_prob[j] = prob_estimates_out[j][p]; } } // mean_dist[j] = mean_dist[j] / (float)count; //printf("mean_dist[%i],%f\n",j,mean_dist[j]); } else { predict_label = svm_predict(model,x); w2_predict = svm_w2(model,x); output_label[j] = (float)predict_label; // mean_dist[j] = 0.; count = 0; l=0; for(p=0;p<nr_class;p++){ for(n=p+1;n<nr_class;n++){ // w2_predict_out[j][l] =(float)w2_predict[l]; if(p+1 == output_label[j] || n+1 == output_label[j]){ // mean_dist[j] = mean_dist[j] + w2_predict_out[j][l]; count = count + 1; } l++; } } // mean_dist[j] = mean_dist[j] / (float)count; } } for (j=0; j< num_rest_pixel; j++){ offset = (long)(sizeof(float)) * (tab_addr[num_block*max_num_pixel + j]); fseek (output, offset, SEEK_SET); fwrite(&output_label[j], sizeof(float), 1, output); } /* for (l=0; l< nr_class*(nr_class-1)/2; l++){ for (j=0; j< num_rest_pixel; j++){ offset = (long)(sizeof(float)) * (tab_addr[num_block*max_num_pixel + j]); fseek(output_w2, offset + n_img_pixel * sizeof(float) * l, SEEK_SET); fwrite(&w2_predict_out[j][l], sizeof(float), 1, output_w2); } } for (j=0; j< num_rest_pixel; j++){ offset = (long)(sizeof(float)) * (tab_addr[num_block*max_num_pixel + j]); fseek(output_w2, offset + n_img_pixel * sizeof(float) * (nr_class*(nr_class-1)/2), SEEK_SET);// on ecrit la distance moyenne parmi les classif bianaire renvoyant le label final fwrite(&mean_dist[j], sizeof(float), 1, output_w2); } */ if(predict_probability){ //printf("Predict prob if fin apres blockeCRITUR!!!!!!!\n"); for (l=0; l< nr_class; l++){ // On ecrit les cartes de probabilité for (j=0; j< num_rest_pixel; j++){ offset = (long)(sizeof(float)) * (tab_addr[num_block*max_num_pixel + j]); fseek(output_prob, offset + n_img_pixel * sizeof(float) * l, SEEK_SET); fwrite(&prob_estimates_out[j][l], sizeof(float), 1, output_prob); //printf("prob_estimates_out[%i][%i] : %f\n", j, l, prob_estimates_out[j][l]); } } for (j=0; j< num_rest_pixel; j++){ offset = (long)(sizeof(float)) * (tab_addr[num_block*max_num_pixel + j]); fseek(output_prob, offset + n_img_pixel * sizeof(float) * nr_class, SEEK_SET); fwrite(&max_prob[j], sizeof(float), 1, output_prob); } } free_matrix_float(V_pol_rest, num_rest_pixel); // free_matrix_float(w2_predict_out, num_rest_pixel); free_matrix_float(prob_estimates_out, num_rest_pixel); free_vector_float(output_label); free(w2_predict); // free_vector_float(mean_dist); free_vector_float(max_prob); }/* remaning pixel */ free(tab_addr); if(predict_probability) free(prob_estimates); }
PRIVATE void classify(double* prob, double* decValue, struct svm_model* decision_model, double id,int n_seq, double z,double sci, double entropy, int decision_model_type){ FILE *out=stdout; /* Output file */ /************************************/ /* normal model as used in RNAz 1.0 */ /************************************/ if (decision_model_type == 1) { struct svm_node node[5]; double* value; value=(double*)space(sizeof(double)*2); node[0].index = 1; node[0].value = z; node[1].index = 2; node[1].value = sci; node[2].index = 3; node[2].value = id; node[3].index = 4; node[3].value = n_seq; node[4].index =-1; scale_decision_node((struct svm_node*)&node,decision_model_type); svm_predict_values(decision_model,node,value); *decValue=value[0]; svm_predict_probability(decision_model,node,value); *prob=value[0]; free(value); } /****************************************************/ /* dinucleotide model for sequence based alignments */ /****************************************************/ if (decision_model_type == 2) { /* For training we used the z-score and the SCI rounded to tow decimal places. To make results comparable we do it also here. */ char tmp[10]; sprintf(tmp, "%.2f", (double) z); double z_tmp = (double) atof(tmp); sprintf(tmp, "%.2f", (double) sci); double sci_tmp = (double) atof(tmp); /* In some rare cases it might happen that z-score and SCI are out of the training range. In these cases they are just set to the maximum or minimum. */ if (z_tmp > 2.01) z_tmp = 2.01; if (z_tmp < -8.15) z_tmp = -8.15; if (sci_tmp > 1.29) sci_tmp = 1.29; /* construct SVM node and scale parameters */ struct svm_node node[4]; double* value; value=(double*)space(sizeof(double)*2); node[0].index = 1; node[0].value = z_tmp; node[1].index = 2; node[1].value = sci_tmp; node[2].index = 3; node[2].value = entropy; node[3].index =-1; scale_decision_node((struct svm_node*)&node,decision_model_type); /* For training we used scaled variables rounded to five decimal places. To make results comparable we do it also here. */ sprintf(tmp, "%.5f", (double) node[0].value); node[0].value = (double) atof(tmp); sprintf(tmp, "%.5f", (double) node[1].value); node[1].value = (double) atof(tmp); sprintf(tmp, "%.5f", (double) node[2].value); node[2].value = (double) atof(tmp); /* Now predict decision value and probability */ svm_predict_values(decision_model,node,value); *decValue=value[0]; svm_predict_probability(decision_model,node,value); *prob=value[0]; free(value); } /***********************************************************************/ /* dinucleotide model for structural alignments generated by locarnate */ /***********************************************************************/ if (decision_model_type == 3) { /* For training we used the z-score and the SCI rounded to tow decimal places. To make results comparable we do it also here. */ char tmp[10]; sprintf(tmp, "%.2f", (double) z); double z_tmp = (double) atof(tmp); sprintf(tmp, "%.2f", (double) sci); double sci_tmp = (double) atof(tmp); /* In some rare cases it might happen that z-score and SCI are out of the training range. In these cases they are just set to the maximum or minimum. */ if (z_tmp > 2.01) z_tmp = 2.01; if (z_tmp < -8.13) z_tmp = -8.13; if (sci_tmp > 1.31) sci_tmp = 1.31; /*fprintf(out," z: %f, sci: %f, entropy:%f\n",z_tmp,sci_tmp,entropy);*/ /* construct SVM node and scale parameters */ struct svm_node node[4]; double* value; value=(double*)space(sizeof(double)*2); node[0].index = 1; node[0].value = z_tmp; node[1].index = 2; node[1].value = sci_tmp; node[2].index = 3; node[2].value = entropy; node[3].index =-1; scale_decision_node((struct svm_node*)&node,decision_model_type); /* For training we used scaled variables rounded to five decimal places. To make results comparable we do it also here. */ sprintf(tmp, "%.5f", (double) node[0].value); node[0].value = (double) atof(tmp); sprintf(tmp, "%.5f", (double) node[1].value); node[1].value = (double) atof(tmp); sprintf(tmp, "%.5f", (double) node[2].value); node[2].value = (double) atof(tmp); /*fprintf(out," z: %f, sci: %f, entropy:%f\n",node[0].value,node[1].value,node[2].value);*/ /* Now predict decision value and probability */ svm_predict_values(decision_model,node,value); *decValue=value[0]; svm_predict_probability(decision_model,node,value); *prob=value[0]; free(value); } }
//This function is used to recognize continuous SLR in a off-line way. //Since the data should be read in all at once, the class gcmCont is not necessary used. int gcm::patchRun_continuous_PQ(vector<SLR_ST_Skeleton> vSkeletonData, vector<Mat> vDepthData, vector<IplImage*> vColorData, int *rankIndex, double *rankScore) { int window = 40; int kernelFeatureDim = NClass*NTrainSample; //Computing features cout<<"Computing features..."<<endl; oriData2Feature(vSkeletonData, vDepthData, vColorData); ////////////////////////////////////////////////////////////////////////// //Compute P and Q all at once. vector<double*> P; vector<double**> Q; cout<<"Computing P and Q..."<<endl; //computePQ(P, Q, vColorData.size()); //white for (int d=0; d<nDimension; d++) { double dimAve = 0.0; for (int f=0; f<nFrames; f++) { dimAve += feature_ori[f][d]; } dimAve /= nFrames; for (int f=0; f<nFrames; f++) { feature_ori[f][d] -= dimAve; } } //Compute P and Q. int nFrames_PQ = vColorData.size(); for (int i=0; i<nFrames_PQ; i++) { cout<<"Current "<<i<<"/"<<nFrames_PQ<<endl; //Compute P double* tempP = new double[featureDim]; for (int j=0; j<featureDim; j++) { tempP[j] = 0; for (int k=0; k<i; k++) { tempP[j] += feature_ori[k][j]; } } P.push_back(tempP); //To release it when reaching the end of a sentence //Compute Q double** tempQ; tempQ = newMatrix(featureDim, featureDim); for (int f1=0; f1<featureDim; f1++) { for (int f2=0; f2<featureDim; f2++) { tempQ[f1][f2] = 0; for (int l=0; l<i; l++) { tempQ[f1][f2] += feature_ori[f1][l]*feature_ori[f2][l]; } } } Q.push_back(tempQ); //To release it when reaching the end of a sentence } ////////////////////////////////////////////////////////////////////////// double** C = newMatrix(featureDim, featureDim); double* p_temp = new double[featureDim]; //The deltaP double** Pm = newMatrix(featureDim, featureDim); for (int i=window; i<vColorData.size()-window; i++) { int begin = i-window/2; int end = i+window/2; //The matrix from p for (int pf=0; pf<featureDim; pf++) { p_temp[pf] = P[end][pf]-P[begin][pf]; } vector2matrix(p_temp, p_temp, Pm,featureDim); //Compute the covariance matrix for (int l=0; l<featureDim; l++) { for (int m=0; m<featureDim; m++) { C[l][m] = ((Q[end][l][m]-Q[begin][l][m])-Pm[l][m]/(end-begin+1))/(end-begin); } } //Regularization term added for (int d=0; d<nDimension; d++) { for (int d2=0; d2<nDimension; d2++) { //C[d][d2] /= nFrames; if (d == d2) { C[d][d2] += 0.001; } } } //The subspace matrix PQsubspace(C, gcm_subspace); //For debug ofstream foutDebug; foutDebug.open("..\\output\\debug.txt"); for (int i=0; i<featureDim; i++) { for (int j=0; j<subSpaceDim; j++) { foutDebug<<gcm_subspace[i][j]<<"\t"; } foutDebug<<"\n"; } foutDebug << flush; foutDebug.close(); //The SVM classification x[0].index = 0; for (int j=0; j<kernelFeatureDim; j++) { subMatrix(subFeaAll_model, subFea1, 0, featureDim, j*subSpaceDim, subSpaceDim); x[j+1].value = myGcmKernel.Frobenius(subFea1, gcm_subspace, featureDim, subSpaceDim); x[j+1].index=j+1; } x[kernelFeatureDim+1].index=-1; int testID = svm_predict_probability(myModel, x, prob_estimates); cout<<"Frame: "<<i<<"/"<<vColorData.size()-window<<" Result: "<<testID<<endl; } delete[] p_temp; deleteMatrix(Pm,featureDim); deleteMatrix(C, featureDim); //To delete P and Q return 1; // gcmSubspace(); // // x[0].index = 0; // for (int j=0; j<kernelFeatureDim; j++) // { // subMatrix(subFeaAll_model, subFea1, 0, featureDim, j*subSpaceDim, subSpaceDim); // x[j+1].value = myGcmKernel.Frobenius(subFea1, gcm_subspace, featureDim, subSpaceDim); // x[j+1].index=j+1; // } // x[kernelFeatureDim+1].index=-1; // // int testID = svm_predict_probability(myModel, x, prob_estimates); // // //Sort and get the former 5 ranks. // vector<scoreAndIndex> rank; // for (int i=0; i<myModel->nr_class; i++) // { // scoreAndIndex temp; // temp.index = myModel->label[i]; // temp.score = prob_estimates[i]; // rank.push_back(temp); // } // sort(rank.begin(),rank.end(),comp); // // for (int i=0; i<5; i++) // { // rankIndex[i] = rank[i].index; // rankScore[i] = rank[i].score; // } // // // //Release // nFrames = 0; // // return testID; }
void predict(mxArray *plhs[], const mxArray *prhs[], struct svm_model *model, const int predict_probability) { int label_vector_row_num, label_vector_col_num; int feature_number, testing_instance_number; int instance_index; double *ptr_instance, *ptr_label, *ptr_predict_label; double *ptr_prob_estimates, *ptr_dec_values, *ptr; struct svm_node *x; mxArray *pplhs[1]; // transposed instance sparse matrix int correct = 0; int total = 0; double error = 0; double sump = 0, sumt = 0, sumpp = 0, sumtt = 0, sumpt = 0; int svm_type=svm_get_svm_type(model); int nr_class=svm_get_nr_class(model); double *prob_estimates=NULL; // prhs[1] = testing instance matrix feature_number = (int)mxGetN(prhs[1]); testing_instance_number = (int)mxGetM(prhs[1]); label_vector_row_num = (int)mxGetM(prhs[0]); label_vector_col_num = (int)mxGetN(prhs[0]); if(label_vector_row_num!=testing_instance_number) { mexPrintf("Length of label vector does not match # of instances.\n"); fake_answer(plhs); return; } if(label_vector_col_num!=1) { mexPrintf("label (1st argument) should be a vector (# of column is 1).\n"); fake_answer(plhs); return; } ptr_instance = mxGetPr(prhs[1]); ptr_label = mxGetPr(prhs[0]); // transpose instance matrix if(mxIsSparse(prhs[1])) { if(model->param.kernel_type == PRECOMPUTED) { // precomputed kernel requires dense matrix, so we make one mxArray *rhs[1], *lhs[1]; rhs[0] = mxDuplicateArray(prhs[1]); if(mexCallMATLAB(1, lhs, 1, rhs, "full")) { mexPrintf("Error: cannot full testing instance matrix\n"); fake_answer(plhs); return; } ptr_instance = mxGetPr(lhs[0]); mxDestroyArray(rhs[0]); } else { mxArray *pprhs[1]; pprhs[0] = mxDuplicateArray(prhs[1]); if(mexCallMATLAB(1, pplhs, 1, pprhs, "transpose")) { mexPrintf("Error: cannot transpose testing instance matrix\n"); fake_answer(plhs); return; } } } if(predict_probability) { if(svm_type==NU_SVR || svm_type==EPSILON_SVR) mexPrintf("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=%g\n",svm_get_svr_probability(model)); else prob_estimates = (double *) malloc(nr_class*sizeof(double)); } plhs[0] = mxCreateDoubleMatrix(testing_instance_number, 1, mxREAL); if(predict_probability) { // prob estimates are in plhs[2] if(svm_type==C_SVC || svm_type==NU_SVC) plhs[2] = mxCreateDoubleMatrix(testing_instance_number, nr_class, mxREAL); else plhs[2] = mxCreateDoubleMatrix(0, 0, mxREAL); } else { // decision values are in plhs[2] if(svm_type == ONE_CLASS || svm_type == EPSILON_SVR || svm_type == NU_SVR) plhs[2] = mxCreateDoubleMatrix(testing_instance_number, 1, mxREAL); else plhs[2] = mxCreateDoubleMatrix(testing_instance_number, nr_class*(nr_class-1)/2, mxREAL); } ptr_predict_label = mxGetPr(plhs[0]); ptr_prob_estimates = mxGetPr(plhs[2]); ptr_dec_values = mxGetPr(plhs[2]); x = (struct svm_node*)malloc((feature_number+1)*sizeof(struct svm_node) ); for(instance_index=0;instance_index<testing_instance_number;instance_index++) { int i; double target_label, predict_label; target_label = ptr_label[instance_index]; if(mxIsSparse(prhs[1]) && model->param.kernel_type != PRECOMPUTED) // prhs[1]^T is still sparse read_sparse_instance(pplhs[0], instance_index, x); else { for(i=0;i<feature_number;i++) { x[i].index = i+1; x[i].value = ptr_instance[testing_instance_number*i+instance_index]; } x[feature_number].index = -1; } if(predict_probability) { if(svm_type==C_SVC || svm_type==NU_SVC) { predict_label = svm_predict_probability(model, x, prob_estimates); ptr_predict_label[instance_index] = predict_label; for(i=0;i<nr_class;i++) ptr_prob_estimates[instance_index + i * testing_instance_number] = prob_estimates[i]; } else { predict_label = svm_predict(model,x); ptr_predict_label[instance_index] = predict_label; } } else { predict_label = svm_predict(model,x); ptr_predict_label[instance_index] = predict_label; if(svm_type == ONE_CLASS || svm_type == EPSILON_SVR || svm_type == NU_SVR) { double res; svm_predict_values(model, x, &res); ptr_dec_values[instance_index] = res; } else { double *dec_values = (double *) malloc(sizeof(double) * nr_class*(nr_class-1)/2); svm_predict_values(model, x, dec_values); for(i=0;i<(nr_class*(nr_class-1))/2;i++) ptr_dec_values[instance_index + i * testing_instance_number] = dec_values[i]; free(dec_values); } } if(predict_label == target_label) ++correct; error += (predict_label-target_label)*(predict_label-target_label); sump += predict_label; sumt += target_label; sumpp += predict_label*predict_label; sumtt += target_label*target_label; sumpt += predict_label*target_label; ++total; } if(svm_type==NU_SVR || svm_type==EPSILON_SVR) { mexPrintf("Mean squared error = %g (regression)\n",error/total); mexPrintf("Squared correlation coefficient = %g (regression)\n", ((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/ ((total*sumpp-sump*sump)*(total*sumtt-sumt*sumt)) ); } /* else */ /* mexPrintf("Accuracy = %g%% (%d/%d) (classification)\n", */ /* (double)correct/total*100,correct,total); */ // return accuracy, mean squared error, squared correlation coefficient plhs[1] = mxCreateDoubleMatrix(3, 1, mxREAL); ptr = mxGetPr(plhs[1]); ptr[0] = (double)correct/total*100; ptr[1] = error/total; ptr[2] = ((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/ ((total*sumpp-sump*sump)*(total*sumtt-sumt*sumt)); free(x); if(prob_estimates != NULL) free(prob_estimates); }
void predict(int nlhs, mxArray *plhs[], const mxArray *prhs[], struct svm_model *model) { int feature_number, testing_instance_number; int instance_index; double *ptr_instance; double *ptr_prob_estimates; mxArray *tplhs; // temporary storage for plhs[] int svm_type=svm_get_svm_type(model); int nr_class=svm_get_nr_class(model); // prhs[0] = testing instance matrix feature_number = (int)mxGetM(prhs[0]); testing_instance_number = (int)mxGetN(prhs[0]); ptr_instance = mxGetPr(prhs[0]); tplhs = mxCreateDoubleMatrix(testing_instance_number, nr_class, mxREAL); ptr_prob_estimates = mxGetPr(tplhs); int freeInstance = 0; #pragma omp parallel { struct svm_node *x = (struct svm_node*)malloc((feature_number+1)*sizeof(struct svm_node) ); double *prob_estimates = (double *) malloc(nr_class*sizeof(double)); int i,base; double predict_label; int instance_index; while (true) { #pragma omp critical { instance_index = freeInstance; freeInstance++; } if (instance_index >= testing_instance_number) break; base = feature_number*instance_index; for(i=0;i<feature_number;i++) { x[i].index = i+1; x[i].value = ptr_instance[base + i]; } x[feature_number].index = -1; predict_label = svm_predict_probability(model, x, prob_estimates); for(i=0;i<nr_class;i++) ptr_prob_estimates[instance_index + i * testing_instance_number] = prob_estimates[i]; } free(x); free(prob_estimates); } plhs[0] = tplhs; }