Interval based triggers

Monetdb get col/sz
Updated RF/dataproc
Bug fixes and improvements

sdk/DecisionTree.h

@@ -9,49 +9,52 @@ struct DR;
 
 struct DT;
 
-//enum Evaluation {gini, entropy, logLoss};
-
-class DecisionTree{
+class DecisionTree
+{
 public:
+    DT *DTree = nullptr;
+    double minIG;
+    long maxHeight;
+    long feature;
+    long maxFeature;
+    bool isRF;
+    long classes;
+    int *Sparse;
+    double forgetRate;
+    double increaseRate;
+    double initialIR;
+    Evaluation evalue;
+    long Rebuild;
+    long roundNo;
+    long called;
+    long retain;
+    long lastT;
+    long lastAll;
 
-DT* DTree = nullptr;
-int maxHeight;
-long feature;
-long maxFeature;
-long seed;
-long classes;
-int* Sparse;
-double forgetRate;
-Evaluation evalue;
-long Rebuild;
-long roundNo;
-long called;
-long retain;
+    DecisionTree(long f, int *sparse, double forget, long maxFeature, long noClasses, Evaluation e);
 
-DecisionTree(int hight, long f, int* sparse, double forget, long maxFeature, long noClasses, Evaluation e, long r, long rb);
+    void Stablelize();
 
-void Stablelize();
+    void Free();
 
-void Free();
+    minEval findMinGiniDense(double **data, long *result, long *totalT, long size, long col);
 
-minEval findMinGiniDense(double** data, long* result, long* totalT, long size, long col);
+    minEval findMinGiniSparse(double **data, long *result, long *totalT, long size, long col, DT *current);
 
-minEval findMinGiniSparse(double** data, long* result, long* totalT, long size, long col, DT* current);
+    minEval incrementalMinGiniDense(double **data, long *result, long size, long col, long ***count, double **record, long *max, long newCount, long forgetSize, double **forgottenData, long *forgottenClass);
 
-minEval incrementalMinGiniDense(double** data, long* result, long size, long col, long*** count, double** record, long* max, long newCount, long forgetSize, bool isRoot);
+    minEval incrementalMinGiniSparse(double **dataNew, long *resultNew, long sizeNew, long sizeOld, DT *current, long col, long forgetSize, double **forgottenData, long *forgottenClass);
 
-minEval incrementalMinGiniSparse(double** dataNew, long* resultNew, long sizeNew, long sizeOld, DT* current, long col, long forgetSize, bool isRoot);
+    long *fitThenPredict(double **trainData, long *trainResult, long trainSize, double **testData, long testSize);
 
-long* fitThenPredict(double** trainData, long* trainResult, long trainSize, double** testData, long testSize);
+    void fit(double **data, long *result, long size);
 
-void fit(double** data, long* result, long size);
+    void Update(double **data, long *result, long size, DT *current);
 
-void Update(double** data, long* result, long size, DT* current);
+    void IncrementalUpdate(double **data, long *result, long size, DT *current);
 
-void IncrementalUpdate(double** data, long* result, long size, DT* current);
+    long Test(double *data, DT *root);
 
-long Test(double* data, DT* root);
-
-void print(DT* root);
+    void print(DT *root);
 };
 #endif

sdk/Evaluation.cpp

@@ -26,7 +26,7 @@ minEval giniSparse(double** data, long* result, long* d, long size, long col, lo
         double gini1, gini2;
         double c;
         long l, r;
-        for(i=0; i<size; i++){
+        for(i=0; i<size-1; i++){
                 c = data[d[i]][col];
                 if(c==max)break;
                 count[result[d[i]]]++;
@@ -62,7 +62,7 @@ minEval entropySparse(double** data, long* result, long* d, long size, long col,
         double entropy1, entropy2;
         double c;
         long l, r;
-        for(i=0; i<size; i++){
+        for(i=0; i<size-1; i++){
                 c = data[d[i]][col];
                 if(c==max)break;
                 count[result[d[i]]]++;
@@ -73,8 +73,8 @@ minEval entropySparse(double** data, long* result, long* d, long size, long col,
                 for(j=0;j<classes;j++){
                         l = count[j];
                         r = totalT[j]-l;
-                        entropy1 -= ((double)l/total)*log((double)l/total);
-                        entropy2 -= ((double)r/(size-total))*log((double)r/(size-total));
+                        if(l!=0)entropy1 -= ((double)l/total)*log((double)l/total);
+                        if(r!=0)entropy2 -= ((double)r/(size-total))*log((double)r/(size-total));
                 }
                 entropy1 = entropy1*total/size + entropy2*(size-total)/size;
                 if(ret.eval>entropy1){
@@ -140,8 +140,8 @@ minEval entropySparseIncremental(long sizeTotal, long classes, double* newSorted
                 for(j=0;j<classes;j++){
                         l = count[j];
                         r = T[j]-l;
-                        e1 -= ((double)l/total)*log((double)l/total);
-                        e2 -= ((double)r/(sizeTotal-total))*log((double)r/(sizeTotal-total));
+                        if(l!=0)e1 -= ((double)l/total)*log((double)l/total);
+                        if(r!=0)e2 -= ((double)r/(sizeTotal-total))*log((double)r/(sizeTotal-total));
                 }
                 e1 = e1*total/sizeTotal + e2*(sizeTotal-total)/sizeTotal;
                 if(ret.eval>e1){
@@ -159,9 +159,9 @@ minEval giniDense(long max, long size, long classes, long** rem, long* d, double
 	double gini1, gini2;
 	long *t, *t2, *r, *r2, i, j;
         for(i=0;i<max;i++){
-                t = rem[d[i]];
+                t = rem[i];
                 if(i>0){
-                        t2 = rem[d[i-1]];
+                        t2 = rem[i-1];
                         for(j=0;j<=classes;j++){
                                 t[j]+=t2[j];
                         }
@@ -179,7 +179,7 @@ minEval giniDense(long max, long size, long classes, long** rem, long* d, double
                 gini1 = (gini1*t[classes])/size + (gini2*(size-t[classes]))/size;
                 if(gini1<ret.eval){
                         ret.eval = gini1;
-                        ret.value = record[d[i]];
+                        ret.value = record[i];
                         ret.left = t[classes];
                 }
 	}
@@ -193,9 +193,9 @@ minEval entropyDense(long max, long size, long classes, long** rem, long* d, dou
 	double entropy1, entropy2;
 	long *t, *t2, *r, *r2, i, j;
         for(i=0;i<max;i++){
-                t = rem[d[i]];
+                t = rem[i];
                 if(i>0){
-                        t2 = rem[d[i-1]];
+                        t2 = rem[i-1];
                         for(j=0;j<=classes;j++){
                                 t[j]+=t2[j];
                         }
@@ -207,71 +207,15 @@ minEval entropyDense(long max, long size, long classes, long** rem, long* d, dou
                         long l, r;
                         l = t[j];
                         r = totalT[j]-l;
-                        entropy1 -= ((double)l/t[classes])*log((double)l/t[classes]);
-                        entropy2 -= ((double)r/(size-t[classes]))*log((double)r/(size-t[classes]));
+                        if(l!=0)entropy1 -= ((double)l/t[classes])*log((double)l/t[classes]);
+                        if(r!=0)entropy2 -= ((double)r/(size-t[classes]))*log((double)r/(size-t[classes]));
                 }
                 entropy1 = entropy1*t[classes]/size + entropy2*(size-t[classes])/size;
                 if(entropy1<ret.eval){
                         ret.eval = entropy1;
-                        ret.value = record[d[i]];
+                        ret.value = record[i];
                         ret.left = t[classes];
                 }
         }
 	return ret;
 }
-
-minEval giniDenseIncremental(long max, double* record, long** count, long classes, long newSize, long* T){
-	double gini1, gini2;
-        minEval ret;
-	long i, j;
-
-	ret.eval = DBL_MAX;
-        for(i=0; i<max; i++){
-                if(count[i][classes]==newSize){
-                        continue;
-                }
-                gini1 = 1.0;
-                gini2 = 1.0;
-                for(j=0;j<classes;j++){
-                        long l, r;
-                        l = count[i][j];
-                        r = T[j]-l;
-                        gini1 -= pow((double)l/count[i][classes], 2);
-                        gini2 -= pow((double)r/(newSize-count[i][classes]), 2);
-                }
-                gini1 = gini1*count[i][classes]/newSize + gini2*((newSize-count[i][classes]))/newSize;
-                if(gini1<ret.eval){
-                        ret.eval = gini1;
-                        ret.value = record[i];
-                }
-        }
-	return ret;
-}
-
-minEval entropyDenseIncremental(long max, double* record, long** count, long classes, long newSize, long* T){
-        double entropy1, entropy2;
-        minEval ret;
-        long i, j;
-
-        ret.eval = DBL_MAX;
-        for(i=0; i<max; i++){
-                if(count[i][classes]==newSize or count[i][classes]==0){
-                        continue;
-                }
-                entropy1 = 0;
-                entropy2 = 0;
-                for(j=0;j<classes;j++){
-                        long l, r;
-                        l = count[i][j];
-                        r = T[j]-l;
-                        entropy1 -= ((double)l/count[i][classes])*log((double)l/count[i][classes]);
-                        entropy2 -= (double)r/(newSize-count[i][classes])*log((double)r/(newSize-count[i][classes]));
-                }
-                entropy1 = entropy1*count[i][classes]/newSize + entropy2*((newSize-count[i][classes]))/newSize;
-                if(entropy1<ret.eval){
-                        ret.eval = entropy1;
-                        ret.value = record[i];
-                }
-        }
-        return ret;
-}

sdk/Evaluation.h

@@ -17,8 +17,4 @@ minEval giniDense(long max, long size, long classes, long** rem, long* d, double
 
 minEval entropyDense(long max, long size, long classes, long** rem, long* d, double* record, long* totalT);
 
-minEval giniDenseIncremental(long max, double* record, long** count, long classes, long newSize, long* T);
-
-minEval entropyDenseIncremental(long max, double* record, long** count, long classes, long newSize, long* T);
-
 #endif

sdk/RF.cpp

@@ -2,7 +2,27 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctime>
+#include <math.h>
+#include <algorithm>
+#include <boost/math/distributions/students_t.hpp>
+#include <random>
 
+long poisson(int Lambda)
+{
+	int  k = 0;
+	long double p = 1.0;
+	long double l = exp(-Lambda);
+	srand((long)clock());
+	
+	while(p>=l)
+	{
+		double u = (double)(rand()%10000)/10000;
+		p *= u;
+		k++;
+	}
+	if (k>11)k=11;
+	return k-1;
+}
 struct DT{
         int height;
         long* featureId;
@@ -30,62 +50,126 @@ struct DT{
         long size = 0;// Size of the dataset
 };
 
-RandomForest::RandomForest(long mTree, long actTree, long rTime, int h, long feature, int* s, double forg, long maxF, long noC, Evaluation eval, long r, long rb){
+RandomForest::RandomForest(long mTree, long feature, int* s, double forg, long noC, Evaluation eval, bool b, double t){
 	srand((long)clock());
-	Rebuild = rb;
-	if(actTree<1)actTree=1;
-	noTree = actTree;
-	activeTree = actTree;
-	treePointer = 0;
-	if(mTree<actTree)mTree=activeTree;
+	bagging = b;
+	activeTree = mTree;
 	maxTree = mTree;
-	if(rTime<=0)rTime=1;
-	rotateTime = rTime;
-	timer = 0;
-	retain = r;	
+	allT = new long[mTree];
 
+	tThresh=t;
+	lastT = -2;
+	lastAll = 0;
 	long i;
-	height = h;
 	f = feature;
 	sparse = new int[f];
 	for(i=0; i<f; i++)sparse[i]=s[i];
 	forget = forg;
-	maxFeature = maxF;
 	noClasses = noC;
 	e = eval;
-
+	minF = floor(sqrt((double)f))+2;
+	if(minF>f)minF=f;
 	DTrees = (DecisionTree**)malloc(mTree*sizeof(DecisionTree*));
-	for(i=0; i<mTree; i++){
-		if(i<actTree){
-			DTrees[i] = new DecisionTree(height, f, sparse, forget, maxFeature, noClasses, e, r, rb);
-		}
-		else{
-			DTrees[i]=nullptr;
-		}
+	for(i=0; i<maxTree; i++){
+		DTrees[i] = new DecisionTree(f, sparse, forget, minF+rand()%(f+1-minF), noClasses, e);
+		DTrees[i]->isRF=true;
 	}
 }
 
 void RandomForest::fit(double** data, long* result, long size){
-	if(timer==rotateTime and maxTree!=activeTree){
-		Rotate();
-		timer=0;
-	}
-	long i, j, k;
+	long i, j, k, l;
 	double** newData;
 	long* newResult;
-	for(i=0; i<activeTree; i++){
-		newData = new double*[size];
-		newResult = new long[size];
-		for(j = 0; j<size; j++){
-			newData[j] = new double[f];
-			for(k=0; k<f; k++){
-				newData[j][k] = data[j][k];
+	long localT = 0;
+	int stale = 0;
+	if(lastT==-2){
+		lastT=-1;
+	}else{
+		for(i=0; i<maxTree; i++)allT[i] = 0;
+		for(i=0; i<size; i++){
+                	if(Test(data[i], result[i])==result[i])localT++;
+        	}
+		long localAll = size;
+		if(lastT>=0){
+			double lastSm = (double)lastT/lastAll;
+                        double localSm = (double)localT/localAll;
+                        double lastSd = sqrt(pow((1.0-lastSm),2)*lastT+pow(lastSm,2)*(lastAll-lastT)/(lastAll-1));
+                        double localSd = sqrt(pow((1.0-localSm),2)*localT+pow(localSm,2)*(localAll-localT)/(localAll-1));
+                        double v = lastAll+localAll-2;
+                        double sp = sqrt(((lastAll-1) * lastSd * lastSd + (localAll-1) * localSd * localSd) / v);
+                        double q;
+			double t = lastSm-localSm;
+			if(sp==0){q = 1;}
+			else{
+				t = t/(sp*sqrt(1.0/lastAll+1.0/localAll));
+                        	boost::math::students_t dist(v);
+                        	double c = cdf(dist, t);
+				q = cdf(complement(dist, fabs(t)));
 			}
-			newResult[j] = result[j];
+                        if(q<=tThresh){
+				lastT += localT;
+				lastAll += localAll;
+			}else if(t<0){
+				lastT = localT;
+				lastAll = localAll;
+			}else{
+				double newAcc = (double)localT/localAll;
+				double lastAcc= (double)lastT/lastAll;
+				stale = floor((newAcc-lastAcc)/(lastAcc)*maxTree);
+				lastT = localT;
+				lastAll = localAll;
+			}
+		}else{
+			lastT = localT;
+			lastAll = localAll;
 		}
-		DTrees[(i+treePointer)%maxTree]->fit(newData, newResult, size);
 	}
-	timer++;
+	Rotate(stale);
+	for(i=0; i<maxTree; i++){
+		long times;
+	       	if(bagging)times = poisson(6);
+		else times=1;
+		if(times==0)continue;
+		newData = (double**)malloc(sizeof(double*)*size*times);
+		newResult = (long*)malloc(sizeof(long)*size*times);
+		long c = 0;
+		for(j = 0; j<size*times; j++){
+			long jj;
+		       	if(bagging) jj = rand()%size;
+			else jj=j;
+			newData[j] = (double*)malloc((f+1)*sizeof(double));
+			for(l=0; l<f; l++){
+				newData[j][l] = data[jj][l];
+			}
+			newData[j][f] = 0;
+			newResult[j] = result[jj];
+		}
+		DTrees[i]->fit(newData, newResult, size*times);
+	}
+	/*for(i=0; i<maxTree; i++){
+		//backupTrees[i]->retain = 10*size;
+		//if(backupTrees[i]==nullptr) continue;
+		long times;
+		//times = poisson(posMean);
+		//if(times==0)continue;
+		times=1;
+		newData = (double**)malloc(sizeof(double*)*size*times);
+		newResult = (long*)malloc(sizeof(long)*size*times);
+		long c = 0;
+		for(j = 0; j<size; j++){
+			long jj = rand()%size;
+			jj=j;
+			for(k=0; k<times; k++){
+				newData[j*times+k] = (double*)malloc((f+1)*sizeof(double));
+				for(l=0; l<f; l++){
+					newData[j*times+k][l] = data[jj][l];
+				}
+				newData[j*times+k][f] = 0;
+				newResult[j*times+k] = result[jj];
+			}
+		}
+		backupTrees[i]->fit(newData, newResult, size*times);
+	}*/
 }
 
 long* RandomForest::fitThenPredict(double** trainData, long* trainResult, long trainSize, double** testData, long testSize){
@@ -97,36 +181,80 @@ long* RandomForest::fitThenPredict(double** trainData, long* trainResult, long t
         return testResult;
 }
 
-void RandomForest::Rotate(){
-	if(noTree==maxTree){
-		DTrees[(treePointer+activeTree)%maxTree]->Free();
-		delete DTrees[(treePointer+activeTree)%maxTree];
-	}else{
-		noTree++;
+void RandomForest::Rotate(long stale){
+	long i, j, k;
+	long minIndex = -1;
+	if(stale>=0)return;
+	else{
+		stale = std::min(stale, maxTree);
+		stale*=-1;
+		while(stale>0){
+			long currentMin = 2147483647;
+			for(i = 0; i<maxTree; i++){
+				if(allT[i]<currentMin){
+					currentMin=allT[i];
+					minIndex=i;
+				}
+			}
+			stale--;
+			if(minIndex<0)break;
+			allT[minIndex] = 2147483647; 
+				double** newData;
+				long* newResult;
+				long size = 0;
+				long lastT2 = 0;
+				size = DTrees[minIndex]->DTree->size;
+				newData = (double**)malloc(sizeof(double*)*size);
+				newResult = (long*)malloc(sizeof(long)*size);
+				for(j = 0; j<size; j++){
+					newData[j] = (double*)malloc(sizeof(double)*(f+1));
+               				for(k=0; k<f; k++){
+                       				newData[j][k] = DTrees[minIndex]->DTree->dataRecord[j][k];
+                			}
+					newData[j][f] = 0;
+                			newResult[j] = DTrees[minIndex]->DTree->resultRecord[j];
+        			}
+				DTrees[minIndex]->Stablelize();
+				DTrees[minIndex]->Free();
+				delete DTrees[minIndex];
+				DTrees[minIndex] = new DecisionTree(f, sparse, forget, minF+rand()%(f+1-minF), noClasses, e);
+				DTrees[minIndex]->isRF=true;
+				DTrees[minIndex]->fit(newData, newResult, size);
+				for(j=0; j<size; j++){
+					if(DTrees[minIndex]->Test(newData[j], DTrees[minIndex]->DTree)==newResult[j])lastT2++;
+				}
+				DTrees[minIndex]->lastAll=size;
+				DTrees[minIndex]->lastT=lastT2;
+		}	
 	}
-	DTrees[(treePointer+activeTree)%maxTree] = new DecisionTree(height, f, sparse, forget, maxFeature, noClasses, e, retain, Rebuild);
-	long size = DTrees[(treePointer+activeTree-1)%maxTree]->DTree->size;
-	double** newData = new double*[size];
-	long* newResult = new long[size];
-	for(long j = 0; j<size; j++){
-		newData[j] = new double[f];
-                for(long k=0; k<f; k++){
-                        newData[j][k] = DTrees[(treePointer+activeTree-1)%maxTree]->DTree->dataRecord[j][k];
-                }
-                newResult[j] = DTrees[(treePointer+activeTree-1)%maxTree]->DTree->resultRecord[j];
-        }
-
-	DTrees[(treePointer+activeTree)%maxTree]->fit(newData, newResult, size);
-	DTrees[treePointer]->Stablelize();
-	if(++treePointer==maxTree)treePointer=0;
 }
 
 
+long RandomForest::Test(double* data, long result){
+	long i;
+	long predict[noClasses];
+	for(i=0; i<noClasses; i++){
+		predict[i]=0;
+	}
+	for(i=0; i<maxTree; i++){
+		long tmp = DTrees[i]->Test(data, DTrees[i]->DTree);
+		predict[tmp]++;
+		if(tmp==result)allT[i]++;
+	}
+	
+	long ret = 0;
+	for(i=1; i<noClasses; i++){
+		if(predict[i]>predict[ret])ret = i;
+	}
+
+	return ret;
+}
+
 long RandomForest::Test(double* data){
 	long i;
 	long predict[noClasses];
 	for(i=0; i<noClasses; i++)predict[i]=0;
-	for(i=0; i<noTree; i++){
+	for(i=0; i<maxTree; i++){
 		predict[DTrees[i]->Test(data, DTrees[i]->DTree)]++;
 	}
 	

sdk/RF.h

@@ -14,33 +14,34 @@ struct DT;
 class RandomForest{
 public:
 
-long noTree;
 long maxTree;
 long activeTree;
-long treePointer;
-long rotateTime;
-long timer;
-long retain;
-DecisionTree** DTrees = nullptr;
+long* allT;
+double tThresh;
+DecisionTree** DTrees;
+DecisionTree** backupTrees;
 
 long height;
-long Rebuild;
+bool bagging;
 long f;
 int* sparse;
 double forget;
-long maxFeature;
 long noClasses;
 Evaluation e;
+long lastT;
+long lastAll;
+int minF;
 
-
-RandomForest(long maxTree, long activeTree, long rotateTime, int height, long f, int* sparse, double forget, long maxFeature=0, long noClasses=2, Evaluation e=Evaluation::gini, long r=-1, long rb=2147483647);
+RandomForest(long maxTree, long f, int* sparse, double forget, long noClasses=2, Evaluation e=Evaluation::entropy, bool b=false, double tThresh=0.05);
 
 void fit(double** data, long* result, long size);
 
 long* fitThenPredict(double** trainData, long* trainResult, long trainSize, double** testData, long testSize);
 
-void Rotate();
+void Rotate(long stale);
 
 long Test(double* data);
+
+long Test(double* data, long result);
 };
 #endif

sdk/irf.cpp

@@ -1,63 +1,65 @@
 #include "DecisionTree.h"
-#include "aquery.h"
 // __AQ_NO_SESSION__
 #include "../server/table.h"
+#include "aquery.h"
 
-DecisionTree* dt = nullptr;
+DecisionTree *dt = nullptr;
 
-__AQEXPORT__(bool) newtree(int height, long f, ColRef<int> sparse, double forget, long maxf, long noclasses, Evaluation e, long r, long rb){
-	if(sparse.size!=f)return 0;
-	int* issparse = (int*)malloc(f*sizeof(int));
-	for(long i=0; i<f; i++){
+__AQEXPORT__(bool)
+newtree(int height, long f, ColRef<int> sparse, double forget, long maxf, long noclasses, Evaluation e, long r, long rb)
+{
+	if (sparse.size != f)
+		return false;
+	int *issparse = (int *)malloc(f * sizeof(int));
+	for (long i = 0; i < f; i++)
 		issparse[i] = sparse.container[i];
-	}
-	if(maxf<0)maxf=f;
-	dt = new DecisionTree(height, f, issparse, forget, maxf, noclasses, e, r, rb);
-	return 1;
+
+	if (maxf < 0)
+		maxf = f;
+	dt = new DecisionTree(f, issparse, forget, maxf, noclasses, e);
+	return true;
 }
 
-__AQEXPORT__(bool) fit(ColRef<ColRef<double>> X, ColRef<int> y){
-	if(X.size != y.size)return 0;
-	double** data = (double**)malloc(X.size*sizeof(double*));
-	long* result = (long*)malloc(y.size*sizeof(long));
-	for(long i=0; i<X.size; i++){
-		data[i] = X.container[i].container;
-		result[i] = y.container[i];
-	}
-	data[pt] = (double*)malloc(X.size*sizeof(double));
-	for(j=0; j<X.size; j++){
-		data[pt][j]=X.container[j];
-	}
-	result[pt] = y;
-	pt ++;
-	return 1;
-}
-__AQEXPORT__(bool) fit(vector_type<vector_type<double>> v, vector_type<long> res){
-	double** data = (double**)malloc(v.size*sizeof(double*));
-	for(int i = 0; i < v.size; ++i)
+// size_t pt = 0;
+// __AQEXPORT__(bool) fit(ColRef<ColRef<double>> X, ColRef<int> y){
+// 	if(X.size != y.size)return 0;
+// 	double** data = (double**)malloc(X.size*sizeof(double*));
+// 	long* result = (long*)malloc(y.size*sizeof(long));
+// 	for(long i=0; i<X.size; i++){
+// 		data[i] = X.container[i].container;
+// 		result[i] = y.container[i];
+// 	}
+// 	data[pt] = (double*)malloc(X.size*sizeof(double));
+// 	for(uint32_t j=0; j<X.size; j++){
+// 		data[pt][j]=X.container[j];
+// 	}
+// 	result[pt] = y;
+// 	pt ++;
+// 	return 1;
+// }
+
+__AQEXPORT__(bool)
+fit(vector_type<vector_type<double>> v, vector_type<long> res)
+{
+	double **data = (double **)malloc(v.size * sizeof(double *));
+	for (int i = 0; i < v.size; ++i)
 		data[i] = v.container[i].container;
 	dt->fit(data, res.container, v.size);
 	return true;
 }
 
-__AQEXPORT__(vectortype_cstorage) predict(vector_type<vector_type<double>> v){
-	int* result = (int*)malloc(v.size*sizeof(int));
-	
-	for(long i=0; i<v.size; i++){
-		result[i]=dt->Test(v.container[i].container, dt->DTree);
-		//printf("%d ", result[i]);
-	}
-	auto container = (vector_type<int>*)malloc(sizeof(vector_type<int>));
+__AQEXPORT__(vectortype_cstorage)
+predict(vector_type<vector_type<double>> v)
+{
+	int *result = (int *)malloc(v.size * sizeof(int));
+
+	for (long i = 0; i < v.size; i++)
+		result[i] = dt->Test(v.container[i].container, dt->DTree);
+
+	auto container = (vector_type<int> *)malloc(sizeof(vector_type<int>));
 	container->size = v.size;
 	container->capacity = 0;
 	container->container = result;
-	// container->out(10);
-	// ColRef<vector_type<int>>* col = (ColRef<vector_type<int>>*)malloc(sizeof(ColRef<vector_type<int>>));
 	auto ret = vectortype_cstorage{.container = container, .size = 1, .capacity = 0};
-	// col->initfrom(ret, "sibal");
-	// print(*col);
 	return ret;
-	//return true;
 }
-
-