svm_jni.c

SVM_light是一种非常流行的支持向量机的java接口

	//for(i=0;i<*(totdoc);i++) 
		//free_example(docs[i],1);
	//free(docs);
	//free(target);
	//free(totdoc);
	//free(totwords);
	//free(ndocuments);

	return ret;
}

jobject buildModelData(JNIEnv *env, jobject obj, MODEL* model,JavaParamIDs* ids) {

	SVECTOR *v;
	long NUM_DOCS, NUM_FEAT, j;
	NUM_DOCS = model->sv_num;
	jobjectArray doks = NULL;

	if (NUM_DOCS > 1) {
		// Erstelle ein Java-Array vom Typ jnisvmlight/LabeledFeatureVector 
		doks = (*env)->NewObjectArray(env,(jsize) NUM_DOCS-1, ids->tDataCls, NULL);	
		if (doks == 0) {
			perror("perror: Can't create Java array of type jnisvmlight/LabeledFeatureVector!");
			(*env)->ExceptionDescribe(env); 
			exit(1);
		}

		long u;
		for (u=1; u<NUM_DOCS; u++) {
			// erzeuge fuer alle Dokumente ein neues Objekt vom Typ jnisvmlight/LabeledFeatureVector 
			jobject Data =(*env)->NewObject(env, ids->tDataCls, ids->ConstructorID_tDataCls);

			if (Data == NULL) {
				perror("perror: Can't create object of type  LabeledFeatureVector!");
				(*env)->ExceptionDescribe(env); 
			}

			// fuelle die lable-Membervariable mit zugehoerigem Wert
			jdouble label = (jdouble) model->alpha[u];
			(*env)->SetDoubleField(env, Data, ids->ID_double_label, label);

			// fuelle die factor-Membervariable mit zugehoerigem Wert
			jdouble factor = (jdouble) ((model->supvec[u])->fvec)->factor;
			//(*env)->SetDoubleField(env, Data, ids->ID_double_label, label);

			v = (model->supvec[u])->fvec;
			for (j=0; (v->words[j]).wnum; j++);
			NUM_FEAT = j; 

			//XXX: goes wrong, if NUM_FEAT is too big!!!!
			//jint size = (jint) NUM_FEAT;
			//(*env)->SetIntField(env, Data, ids->MemVarID_size, size);

			// Reserviere Speicherplatz fuer int/double Array zum Aufnehmen der Dokumentenfeatures
			int* intar = (int*) my_malloc(NUM_FEAT*sizeof(int));
			double* doublear = (double*) my_malloc(NUM_FEAT*sizeof(double));
			// Erstelle korrespondierende Java-Arrays
			jintArray dim = (*env)->NewIntArray(env,(jsize) NUM_FEAT);
			jdoubleArray val = (*env)->NewDoubleArray(env,(jsize) NUM_FEAT);

			if (dim && val == NULL) {
				perror("perror: Can't create jint- or jdoubleArrray! :");
				(*env)->ExceptionDescribe(env);
				exit(1);
			}

			for (j=0;j<NUM_FEAT;j++) {
				// Fuelle int/double Arrays mit zugehoerigen Werten
				intar[j] = (int)((v->words[j]).wnum);
				doublear[j] = (double) ((v->words[j]).weight);
				// Lege Referenz auf int/double Werte in Java-Array ab
				(*env)->SetIntArrayRegion(env, dim, (jsize) j, (jsize) 1, (jint*) &intar[j]);
				(*env)->SetDoubleArrayRegion(env, val, (jsize) j, (jsize) 1, (jdouble*) &doublear[j]);
			}

			// Lege Java-Arrays in Objekt des Typs jnisvmlight/LabeledFeatureVector ab
			(*env)->SetObjectField(env, Data, ids->ID_intArray_dimensions, dim);
			(*env)->SetObjectField(env, Data, ids->ID_doubleArray_values, val);
			// lege Objekt vom Type jnisvmlight/LabeledFeatureVector in jnisvmlight/LabeledFeatureVector-Array ab (an Position u-1)
			(*env)->SetObjectArrayElement(env, doks, (jsize) u-1, Data); 

			// ------------------------------------------------------------
			// XXX: TODO: check if i am allowed to free these arrays!!!
			free(intar);
			free(doublear);
			// ------------------------------------------------------------

		} 

		// Lege jnisvmlight/LabeledFeatureVector-Array in zugehoeriger Membervariable des Objekts vom Type SVMLightModel ab
		//  	(*env)->SetObjectField(env, SVMLightModel, ids->ID_labeledFeatureVectorArray_docs, doks);
	} else {
		fprintf(stderr,"-------------------------------------------------------------------------------\nThe number of suppert vecors (model->sv_num: %ld) is less than 2!\nThere must be at least 2 support vectors. Model can't be built.\n",model->sv_num);
		// 	(*env)->SetObjectField(env, SVMLightModel, ids->ID_labeledFeatureVectorArray_docs, NULL);

	}

	char* text = "SVM-light Version ";
	char* dummy = (char*) my_malloc(((int)strlen(VERSION)+strlen(text)+1)*sizeof(char));
	sprintf(dummy,"%s%s",text,VERSION); 

	// kreiere ein neues Objekt vom Typ SVMLightModel 
	jobject SVMLightModel =(*env)->NewObject(env, ids->SVMLightModelCls, ids->ConstructorID_SVMLightModelCls, 
		(*env)->NewStringUTF(env, dummy),
		(jlong) (model->kernel_parm.kernel_type),
		(jlong) (model->kernel_parm.poly_degree),
		(jdouble) (model->kernel_parm.rbf_gamma),
		(jdouble) (model->kernel_parm.coef_lin),
		(jdouble) (model->kernel_parm.coef_const),
		(*env)->NewStringUTF(env, (model->kernel_parm.custom)),
		(jlong) (model->totwords),
		(jlong) (model->totdoc),
		(jlong) (model->sv_num),
		(jdouble) (model->b),
		((model->sv_num > 1) ? doks : (jobjectArray) NULL)
		);

	if ( SVMLightModel == 0) {
		perror("perror: Can't create a new SVMLightModel-Object :");
		(*env)->ExceptionDescribe(env);
		exit(1);
	}

	if ( (model->kernel_parm.kernel_type) == 0 ) {
		jdoubleArray val = (*env)->NewDoubleArray(env,(jsize) model->totwords +1);
		for (j=0;j<model->totwords +1;j++) {
			(*env)->SetDoubleArrayRegion(env, val, (jsize) j, (jsize) 1, (jdouble*) &(model->lin_weights)[j]);
		}
		(*env)->SetObjectField(env, SVMLightModel, ids->ID_doubleArray_linWeights, val);
	} else {
		double nullpointer = 0;
		(*env)->SetObjectField(env, SVMLightModel, ids->ID_doubleArray_linWeights, &nullpointer);
	}

	// Belege restliche Membervariablen des Objekts vom Typ SVMLightModel mit zugehoerigen Werten
	//(*env)->SetObjectField(env, SVMLightModel, ids->ID_string_format, ((*env)->NewStringUTF(env, dummy)));
	free(dummy);

	//(*env)->SetLongField(env, SVMLightModel, ids->ID_long_kType, (jlong) (model->kernel_parm.kernel_type));
	//(*env)->SetLongField(env, SVMLightModel, ids->ID_long_dParam, (jlong) (model->kernel_parm.poly_degree));
	//(*env)->SetDoubleField(env, SVMLightModel, ids->ID_double_gParam, (jdouble) (model->kernel_parm.rbf_gamma));
	//(*env)->SetDoubleField(env, SVMLightModel, ids->ID_double_sParam, (jdouble)  (model->kernel_parm.coef_lin));
	//(*env)->SetDoubleField(env, SVMLightModel, ids->ID_double_rParam, (jdouble) (model->kernel_parm.coef_const) );
	//(*env)->SetObjectField(env, SVMLightModel, ids->ID_string_uParam, (*env)->NewStringUTF(env, (model->kernel_parm.custom)));
	//(*env)->SetLongField(env, SVMLightModel, ids->ID_long_highFeatIdx, (jlong) (model->totwords) );
	//(*env)->SetLongField(env, SVMLightModel, ids->ID_long_trainDocs, (jlong) (model->totdoc));
	//(*env)->SetLongField(env, SVMLightModel, ids->ID_long_numSupVecs, (jlong) (model->sv_num));
	//(*env)->SetDoubleField(env, SVMLightModel, ids->ID_double_threshold, (jdouble) (model->b));

	if(verbosity>=1)
		printf(" --- Native C function: classifier model created successfully.\n"); fflush(stdout);
	return SVMLightModel;
}

void createDOCs(JNIEnv * env,JavaParamIDs *JIDs,jobjectArray* tdata,DOC*** docs, double** target, long* totwords, long* totdoc, long* ndocuments) {

	jboolean ex = 0;
	*ndocuments = 0;
	*totwords = 0;
	*totdoc = (long) JIDs->tDataSize;

	long max_docs=(long) ((JIDs->tDataSize)+3);
	(*docs) = (DOC **)my_malloc(sizeof(DOC *)*max_docs);    /* feature vectors */
	(*target) = (double *)my_malloc(sizeof(double)*max_docs); /* target values */
	long max_words_doc = 10;
	WORD *words = (WORD *)my_malloc(sizeof(WORD)*(max_words_doc+10));


	int k=0;

	FILE *test = NULL;
	int doTest=0;

	if(verbosity>10) {
		doTest=1;
		if ((test = fopen ("jni-train.dat", "w")) == NULL) { perror ("Writing to \"jni-train.dat\" doesn't work.\n"); exit (1); }
	}

	for (k=0; k<JIDs->tDataSize; k++) {

		// Bestimme Referenz auf k-tes Trainingsdokument
		jobject traindoc = (*env)->GetObjectArrayElement(env, *tdata, k);
		if (traindoc == NULL) { 
			if (verbosity>2) {	
				// nexus: debugging ..
				printf("\n\n Debugging: ----------------------------------------------- empty document %d! \n\n",k);
			}
			(*totdoc)--;
			ex = (*env)->ExceptionCheck(env);
			if (ex) { 
				(*env)->ExceptionDescribe(env);
				(*env)->ExceptionClear(env);
			}
			continue; 
		}

		// Lese das Label des k-ten Trainingsdokumentes ein
		jdouble label = (*env)->GetDoubleField(env, traindoc, JIDs->ID_double_label); 
		//if ((label != 1.0) && (label != -1.0)) {
		//	perror("\n\nTraining data with wrong label!\n\n");
		//	exit(1);
		//}

		//if (doTest)
		//	fprintf(test,"%s%lf ",label); fflush(stdout); 

		// Bestimme Speicheradresse der Dimension/Wert-Arrays aus der 
		// Java-Klasse des k-ten Trainingsdokumentes
		jintArray dim = (*env)->GetObjectField(env, traindoc, JIDs->ID_intArray_dimensions); 
		jdoubleArray val = (*env)->GetObjectField(env, traindoc, JIDs->ID_doubleArray_values);
		if ( (dim && val)== 0) {
			perror("---------------------------------------------------------- Can't access Dim/Val-Arrays \n");
			exit(1);
		}

		// Bestimme die Groesse der Dimension/Wert-Arrays aus der 
		// Java-Klasse des k-ten Trainingsdokumentes
		jsize dimLen = (*env)->GetArrayLength(env, dim);
		jsize valLen = (*env)->GetArrayLength(env, val);
		if ((dimLen != valLen) || (dimLen == 0)) {
			perror("---------------------------------------------------------- array length is zero or arrays are of different size!\n");
			exit(1);
		}

		// Referenziere Elemente aus den Java-Arrays aus
		jint *dimEl = (*env)->GetIntArrayElements(env, dim, 0);
		jdouble *valEl = (*env)->GetDoubleArrayElements(env, val, 0);

		int* ds;
		double *vs;

		if (sizeof(int) == sizeof(jint)) {
			ds = (int*) dimEl;
		} else {
			int fi=0;
			printf("!!!!!!!!!!!!!!! Warning: java datatype \"jint\" isn't of the same size as C datatype \"int\"\n");
			ds = (int*) my_malloc(sizeof(int)*dimLen); 
			for(fi=0;fi<dimLen;fi++) {
				ds[fi] = (int) dimEl[fi];
			}
		}

		if (sizeof(double) == sizeof(jdouble)) {
			vs = (double*) valEl;
		} else {
			int fi=0;
			printf("!!!!!!!!!!!!!!! Warning: Java-Datatype (jdouble) isn't of the same size as C datatype");
			vs = (double*) my_malloc(sizeof(double)*valLen); 
			for(fi=0;fi<valLen;fi++) {
				vs[fi] = (double) valEl[fi];
			}
		}

		/*			int g=0;
		printf("%lf",label);
		for (g=0;g<dimLen;g++){
		printf(" %ld:%.16lf ",ds[g],vs[g]);
		}
		printf("\n%lf",label);
		for (g=0;g<dimLen;g++){
		printf(" %ld:%.16lf ",dimEl[g],valEl[g]);
		}

		exit(0); */

		// ------------------------------- fill DOCs --------------------------------------------

		if (dimLen>max_words_doc) {
			free(words);
			max_words_doc=dimLen;
			words = (WORD *)my_malloc(sizeof(WORD)*(dimLen+10));
		}

		// erstelle anhand der Werte aus label,Dimension- und Wert-Array eine Datenstruktur vom Typ DOC
		jinit_traindoc((double)label,docs,target,dimLen,totwords,totdoc, ds, vs, ndocuments, words, test);
		//jinit_traindoc((double)label,docs,target,dimLen,totwords,totdoc, ds, vs, ndocuments, words,NULL);
		(*ndocuments)++;

		// --------------------------------------------------------------------------------------

		// gebe Speicherplatz der Java-Arrays frei
		(*env)->ReleaseIntArrayElements(env,dim,dimEl,0);
		(*env)->ReleaseDoubleArrayElements(env,val,valEl,0);

	}

	free(words);
	if(verbosity>=1) {
		fprintf(stdout, "OK. (%ld examples read)\n", *ndocuments); fflush(stdout);
	}


	if (doTest)
		fclose(test);

}

void jinit_traindoc(double doc_label, DOC ***docs, double **label,
					long max_words_doc, long int *totwords, long int *totdoc, int* dims, 
					double *vals, long* ndocuments, WORD* words, FILE* test) 
{

	char comment[1] = {'\0'}; 
	long dnum=0,wpos,dpos=0,dneg=0,dunlab=0,queryid,slackid;
	double costfactor;

	dnum = *ndocuments;


	if(!jparse_document(words,&queryid,&slackid,&costfactor,
		&wpos,max_words_doc,dims,vals)) {
			perror("\nParsing error in line !\n");
			exit(1);
		}


		int iw=0;
		while(iw<max_words_doc) {
			if (test != NULL) fprintf(test,"%ld:%.32g ",words[iw].wnum,words[iw].weight); fflush(stdout);
			iw++;
		}
		if (test != NULL) fprintf(test,"\n"); fflush(stdout);

		(*label)[dnum]=doc_label;
		/* printf("docnum=%ld: Class=%f ",dnum,doc_label); fflush(stdout); */
		if(doc_label > 0) dpos++;
		if (doc_label < 0) dneg++;
		if (doc_label == 0) dunlab++;

		if((wpos>1) && ((words[wpos-2]).wnum>(*totwords))) 
			(*totwords)=(words[wpos-2]).wnum;
		if((*totwords) > MAXFEATNUM) {
			printf("\nMaximum feature number exceeds limit defined in MAXFEATNUM! (%ld>MAXFEATNUM:%ld)\n",*totwords,(long int)MAXFEATNUM);
			exit(1);
		}

		(*docs)[dnum] = create_example(dnum,queryid,slackid,costfactor,
			create_svector(words,comment,1.0));


		/* printf("\nNorm=%f\n",((*docs)[dnum]->fvec)->twonorm_sq); fflush(stdout);  */
		if(verbosity>=1) {
			if((dnum % 20) == 0) {
				printf("%ld..",dnum); fflush(stdout);
			}
			if (dnum == (*totdoc)-1) {
				printf("%ld\n",dnum); fflush(stdout);
			}
		}
}

int jparse_document(WORD* words, long *queryid, long *slackid, double *costfactor,  long int *numwords, long int max_words_doc, int *dims, double *vals) {
	register long wpos;
	long wnum;
	double weight;

	(*queryid)=0;
	(*slackid)=0;
	(*costfactor)=1;


	wpos=0;
	while(wpos<max_words_doc) {

		wnum = dims[wpos];
		weight = vals[wpos]; //(FVAL) vals[wpos];

		if(wnum<=0) { 
			perror ("Feature numbers must be larger or equal to 1!!!\n"); 
			exit (1); 
		}

		if((wpos>0) && ((words[wpos-1]).wnum >= wnum)) { 
			perror ("Features must be in increasing order!!!\n"); 
			exit(1);
		}

		(words[wpos]).wnum=wnum;
		(words[wpos]).weight=(FVAL)weight; 

		wpos++;
	}

	(words[wpos]).wnum=0;
	(*numwords)=wpos+1;

	return(1);
}