/*************************************************************************
* Unsets DF
*************************************************************************/
private static void unsetdf(ref dforest.decisionforest df)
{
double[,] xy = new double[0, 0];
int info = 0;
dforest.dfreport rep = new dforest.dfreport();
xy = new double[0 + 1, 1 + 1];
xy[0, 0] = 0;
xy[0, 1] = 0;
dforest.dfbuildinternal(ref xy, 1, 1, 1, 1, 1, 1, 0, ref info, ref df, ref rep);
}
public dfreport(dforest.dfreport obj)
{
_innerobj = obj;
}
public dfreport()
{
_innerobj = new dforest.dfreport();
}
/*************************************************************************
Unsets DF
*************************************************************************/
private static void unsetdf(dforest.decisionforest df)
{
double[,] xy = new double[0,0];
int info = 0;
dforest.dfreport rep = new dforest.dfreport();
xy = new double[0+1, 1+1];
xy[0,0] = 0;
xy[0,1] = 0;
dforest.dfbuildinternal(xy, 1, 1, 1, 1, 1, 1, 0, ref info, df, rep);
}
/*************************************************************************
Basic test: extended variable selection leads to better results.
Next task CAN be solved without EVS but it is very unlikely. With EVS
it can be easily and exactly solved.
Task matrix:
1 0 0 0 ... 0 0
0 1 0 0 ... 0 1
0 0 1 0 ... 0 2
0 0 0 1 ... 0 3
0 0 0 0 ... 1 N-1
*************************************************************************/
private static void basictest5(ref bool err)
{
double[,] xy = new double[0,0];
int nvars = 0;
int npoints = 0;
int nfeatures = 0;
int nsample = 0;
int ntrees = 0;
int evs = 0;
int i = 0;
int j = 0;
bool eflag = new bool();
int info = 0;
dforest.decisionforest df = new dforest.decisionforest();
double[] x = new double[0];
double[] y = new double[0];
dforest.dfreport rep = new dforest.dfreport();
int i_ = 0;
//
// select npoints and ntrees
//
npoints = 50;
nvars = npoints;
ntrees = 1;
nsample = npoints;
evs = 2;
nfeatures = 1;
//
// Prepare task
//
xy = new double[npoints-1+1, nvars+1];
x = new double[nvars-1+1];
y = new double[0+1];
for(i=0; i<=npoints-1; i++)
{
for(j=0; j<=nvars-1; j++)
{
xy[i,j] = 0;
}
xy[i,i] = 1;
xy[i,nvars] = i;
}
//
// Without EVS
//
dforest.dfbuildinternal(xy, npoints, nvars, 1, ntrees, nsample, nfeatures, 0, ref info, df, rep);
if( info<=0 )
{
err = true;
return;
}
eflag = false;
for(i=0; i<=npoints-1; i++)
{
for(i_=0; i_<=nvars-1;i_++)
{
x[i_] = xy[i,i_];
}
dforest.dfprocess(df, x, ref y);
if( (double)(Math.Abs(y[0]-xy[i,nvars]))>(double)(1000*math.machineepsilon) )
{
eflag = true;
}
}
if( !eflag )
{
err = true;
return;
}
//
// With EVS
//
dforest.dfbuildinternal(xy, npoints, nvars, 1, ntrees, nsample, nfeatures, evs, ref info, df, rep);
if( info<=0 )
{
err = true;
return;
}
eflag = false;
for(i=0; i<=npoints-1; i++)
{
for(i_=0; i_<=nvars-1;i_++)
{
x[i_] = xy[i,i_];
}
dforest.dfprocess(df, x, ref y);
if( (double)(Math.Abs(y[0]-xy[i,nvars]))>(double)(1000*math.machineepsilon) )
{
eflag = true;
}
}
if( eflag )
{
err = true;
return;
}
}
/*************************************************************************
Basic test: simple regression task without noise:
* |x|<1, |y|<1
* F(x,y) = x^2+y
*************************************************************************/
private static void basictest4(ref bool err)
{
int pass = 0;
int passcount = 0;
double[,] xy = new double[0,0];
int npoints = 0;
int ntrees = 0;
int ns = 0;
int strongc = 0;
int i = 0;
int j = 0;
int info = 0;
dforest.decisionforest df = new dforest.decisionforest();
dforest.decisionforest df2 = new dforest.decisionforest();
double[] x = new double[0];
double[] y = new double[0];
dforest.dfreport rep = new dforest.dfreport();
dforest.dfreport rep2 = new dforest.dfreport();
int testgridsize = 0;
double maxerr = 0;
double maxerr2 = 0;
double avgerr = 0;
double avgerr2 = 0;
int cnt = 0;
double ey = 0;
passcount = 1;
testgridsize = 50;
for(pass=1; pass<=passcount; pass++)
{
//
// select npoints and ntrees
//
npoints = 5000;
ntrees = 100;
ns = (int)Math.Round(0.1*npoints);
strongc = 1;
//
// Prepare task
//
xy = new double[npoints-1+1, 2+1];
x = new double[1+1];
y = new double[0+1];
for(i=0; i<=npoints-1; i++)
{
xy[i,0] = 2*math.randomreal()-1;
xy[i,1] = 2*math.randomreal()-1;
xy[i,2] = math.sqr(xy[i,0])+xy[i,1];
}
//
// Test
//
dforest.dfbuildinternal(xy, npoints, 2, 1, ntrees, ns, 1, 0, ref info, df, rep);
if( info<=0 )
{
err = true;
return;
}
dforest.dfbuildinternal(xy, npoints, 2, 1, ntrees, ns, 1, strongc, ref info, df2, rep2);
if( info<=0 )
{
err = true;
return;
}
maxerr = 0;
maxerr2 = 0;
avgerr = 0;
avgerr2 = 0;
cnt = 0;
for(i=(int)Math.Round(-(0.7*testgridsize/2)); i<=(int)Math.Round(0.7*testgridsize/2); i++)
{
for(j=(int)Math.Round(-(0.7*testgridsize/2)); j<=(int)Math.Round(0.7*testgridsize/2); j++)
{
x[0] = (double)i/(double)(testgridsize/2);
x[1] = (double)j/(double)(testgridsize/2);
ey = math.sqr(x[0])+x[1];
dforest.dfprocess(df, x, ref y);
maxerr = Math.Max(maxerr, Math.Abs(y[0]-ey));
avgerr = avgerr+Math.Abs(y[0]-ey);
dforest.dfprocess(df2, x, ref y);
maxerr2 = Math.Max(maxerr2, Math.Abs(y[0]-ey));
avgerr2 = avgerr2+Math.Abs(y[0]-ey);
cnt = cnt+1;
}
}
avgerr = avgerr/cnt;
avgerr2 = avgerr2/cnt;
err = err | (double)(maxerr)>(double)(0.2);
err = err | (double)(maxerr2)>(double)(0.2);
err = err | (double)(avgerr)>(double)(0.1);
err = err | (double)(avgerr2)>(double)(0.1);
}
}
/*************************************************************************
Basic test: tests generalization ability on a simple classification task
(no noise):
* |x|<1, |y|<1
* x^2+y^2<=0.25 - P(class=0)=1
* x^2+y^2>0.25 - P(class=0)=0
*************************************************************************/
private static void basictest3(ref bool err)
{
int pass = 0;
int passcount = 0;
double[,] xy = new double[0,0];
int npoints = 0;
int ntrees = 0;
int i = 0;
int j = 0;
int k = 0;
double s = 0;
int info = 0;
dforest.decisionforest df = new dforest.decisionforest();
double[] x = new double[0];
double[] y = new double[0];
dforest.dfreport rep = new dforest.dfreport();
int testgridsize = 0;
double r = 0;
passcount = 1;
testgridsize = 50;
for(pass=1; pass<=passcount; pass++)
{
//
// select npoints and ntrees
//
npoints = 2000;
ntrees = 100;
//
// Prepare task
//
xy = new double[npoints-1+1, 2+1];
x = new double[1+1];
y = new double[1+1];
for(i=0; i<=npoints-1; i++)
{
xy[i,0] = 2*math.randomreal()-1;
xy[i,1] = 2*math.randomreal()-1;
if( (double)(math.sqr(xy[i,0])+math.sqr(xy[i,1]))<=(double)(0.25) )
{
xy[i,2] = 0;
}
else
{
xy[i,2] = 1;
}
}
//
// Test
//
dforest.dfbuildinternal(xy, npoints, 2, 2, ntrees, (int)Math.Round(0.1*npoints), 1, 0, ref info, df, rep);
if( info<=0 )
{
err = true;
return;
}
for(i=-(testgridsize/2); i<=testgridsize/2; i++)
{
for(j=-(testgridsize/2); j<=testgridsize/2; j++)
{
x[0] = (double)i/(double)(testgridsize/2);
x[1] = (double)j/(double)(testgridsize/2);
dforest.dfprocess(df, x, ref y);
//
// Test for basic properties
//
s = 0;
for(k=0; k<=1; k++)
{
if( (double)(y[k])<(double)(0) )
{
err = true;
return;
}
s = s+y[k];
}
if( (double)(Math.Abs(s-1))>(double)(1000*math.machineepsilon) )
{
err = true;
return;
}
//
// test for good correlation with results
//
r = Math.Sqrt(math.sqr(x[0])+math.sqr(x[1]));
if( (double)(r)<(double)(0.5*0.5) )
{
err = err | (double)(y[0])<(double)(0.6);
}
if( (double)(r)>(double)(0.5*1.5) )
{
err = err | (double)(y[1])<(double)(0.6);
}
}
}
}
}
/*************************************************************************
Basic test: tests generalization ability on a simple noisy classification
task:
* 0<x<1 - P(class=0)=1
* 1<x<2 - P(class=0)=2-x
* 2<x<3 - P(class=0)=0
*************************************************************************/
private static void basictest2(ref bool err)
{
int pass = 0;
int passcount = 0;
double[,] xy = new double[0,0];
int npoints = 0;
int ntrees = 0;
int i = 0;
int j = 0;
double s = 0;
int info = 0;
dforest.decisionforest df = new dforest.decisionforest();
double[] x = new double[0];
double[] y = new double[0];
dforest.dfreport rep = new dforest.dfreport();
passcount = 1;
for(pass=1; pass<=passcount; pass++)
{
//
// select npoints and ntrees
//
npoints = 3000;
ntrees = 50;
//
// Prepare task
//
xy = new double[npoints-1+1, 1+1];
x = new double[0+1];
y = new double[1+1];
for(i=0; i<=npoints-1; i++)
{
xy[i,0] = 3*math.randomreal();
if( (double)(xy[i,0])<=(double)(1) )
{
xy[i,1] = 0;
}
else
{
if( (double)(xy[i,0])<=(double)(2) )
{
if( (double)(math.randomreal())<(double)(xy[i,0]-1) )
{
xy[i,1] = 1;
}
else
{
xy[i,1] = 0;
}
}
else
{
xy[i,1] = 1;
}
}
}
//
// Test
//
dforest.dfbuildinternal(xy, npoints, 1, 2, ntrees, (int)Math.Round(0.05*npoints), 1, 0, ref info, df, rep);
if( info<=0 )
{
err = true;
return;
}
x[0] = 0.0;
while( (double)(x[0])<=(double)(3.0) )
{
dforest.dfprocess(df, x, ref y);
//
// Test for basic properties
//
s = 0;
for(j=0; j<=1; j++)
{
if( (double)(y[j])<(double)(0) )
{
err = true;
return;
}
s = s+y[j];
}
if( (double)(Math.Abs(s-1))>(double)(1000*math.machineepsilon) )
{
err = true;
return;
}
//
// test for good correlation with results
//
if( (double)(x[0])<(double)(1) )
{
err = err | (double)(y[0])<(double)(0.8);
}
if( (double)(x[0])>=(double)(1) & (double)(x[0])<=(double)(2) )
{
err = err | (double)(Math.Abs(y[1]-(x[0]-1)))>(double)(0.5);
}
if( (double)(x[0])>(double)(2) )
{
err = err | (double)(y[1])<(double)(0.8);
}
x[0] = x[0]+0.01;
}
}
}
/*************************************************************************
Basic test: one-tree forest built using full sample must remember all the
training cases
*************************************************************************/
private static void basictest1(int nvars,
int nclasses,
int passcount,
ref bool err)
{
int pass = 0;
double[,] xy = new double[0,0];
int npoints = 0;
int i = 0;
int j = 0;
int k = 0;
double s = 0;
int info = 0;
dforest.decisionforest df = new dforest.decisionforest();
double[] x = new double[0];
double[] y = new double[0];
dforest.dfreport rep = new dforest.dfreport();
bool hassame = new bool();
int i_ = 0;
if( nclasses==1 )
{
//
// only classification tasks
//
return;
}
for(pass=1; pass<=passcount; pass++)
{
//
// select number of points
//
if( pass<=3 & passcount>3 )
{
npoints = pass;
}
else
{
npoints = 100+math.randominteger(100);
}
//
// Prepare task
//
xy = new double[npoints-1+1, nvars+1];
x = new double[nvars-1+1];
y = new double[nclasses-1+1];
for(i=0; i<=npoints-1; i++)
{
for(j=0; j<=nvars-1; j++)
{
xy[i,j] = 2*math.randomreal()-1;
}
xy[i,nvars] = math.randominteger(nclasses);
}
//
// Test
//
dforest.dfbuildinternal(xy, npoints, nvars, nclasses, 1, npoints, 1, 1, ref info, df, rep);
if( info<=0 )
{
err = true;
return;
}
for(i=0; i<=npoints-1; i++)
{
for(i_=0; i_<=nvars-1;i_++)
{
x[i_] = xy[i,i_];
}
dforest.dfprocess(df, x, ref y);
s = 0;
for(j=0; j<=nclasses-1; j++)
{
if( (double)(y[j])<(double)(0) )
{
err = true;
return;
}
s = s+y[j];
}
if( (double)(Math.Abs(s-1))>(double)(1000*math.machineepsilon) )
{
err = true;
return;
}
if( (double)(Math.Abs(y[(int)Math.Round(xy[i,nvars])]-1))>(double)(1000*math.machineepsilon) )
{
//
// not an error if there exists such K,J that XY[K,J]=XY[I,J]
// (may be we just can't distinguish two tied values).
//
// definitely error otherwise.
//
hassame = false;
for(k=0; k<=npoints-1; k++)
{
if( k!=i )
{
for(j=0; j<=nvars-1; j++)
{
if( (double)(xy[k,j])==(double)(xy[i,j]) )
{
hassame = true;
}
}
}
}
if( !hassame )
{
err = true;
return;
}
}
}
}
}
/*************************************************************************
Processing functions test
*************************************************************************/
private static void testprocessing(ref bool err)
{
int nvars = 0;
int nclasses = 0;
int nsample = 0;
int ntrees = 0;
int nfeatures = 0;
int flags = 0;
dforest.decisionforest df1 = new dforest.decisionforest();
dforest.decisionforest df2 = new dforest.decisionforest();
int npoints = 0;
double[,] xy = new double[0,0];
int pass = 0;
int passcount = 0;
int i = 0;
int j = 0;
bool allsame = new bool();
int info = 0;
dforest.dfreport rep = new dforest.dfreport();
double[] x1 = new double[0];
double[] x2 = new double[0];
double[] y1 = new double[0];
double[] y2 = new double[0];
double v = 0;
passcount = 100;
//
// Main cycle
//
for(pass=1; pass<=passcount; pass++)
{
//
// initialize parameters
//
nvars = 1+math.randominteger(5);
nclasses = 1+math.randominteger(3);
ntrees = 1+math.randominteger(4);
nfeatures = 1+math.randominteger(nvars);
flags = 0;
if( (double)(math.randomreal())>(double)(0.5) )
{
flags = flags+2;
}
//
// Initialize arrays and data
//
npoints = 10+math.randominteger(50);
nsample = Math.Max(10, math.randominteger(npoints));
x1 = new double[nvars-1+1];
x2 = new double[nvars-1+1];
y1 = new double[nclasses-1+1];
y2 = new double[nclasses-1+1];
xy = new double[npoints-1+1, nvars+1];
for(i=0; i<=npoints-1; i++)
{
for(j=0; j<=nvars-1; j++)
{
if( j%2==0 )
{
xy[i,j] = 2*math.randomreal()-1;
}
else
{
xy[i,j] = math.randominteger(2);
}
}
if( nclasses==1 )
{
xy[i,nvars] = 2*math.randomreal()-1;
}
else
{
xy[i,nvars] = math.randominteger(nclasses);
}
}
//
// create forest
//
dforest.dfbuildinternal(xy, npoints, nvars, nclasses, ntrees, nsample, nfeatures, flags, ref info, df1, rep);
if( info<=0 )
{
err = true;
return;
}
//
// Same inputs leads to same outputs
//
for(i=0; i<=nvars-1; i++)
{
x1[i] = 2*math.randomreal()-1;
x2[i] = x1[i];
}
for(i=0; i<=nclasses-1; i++)
{
y1[i] = 2*math.randomreal()-1;
y2[i] = 2*math.randomreal()-1;
}
dforest.dfprocess(df1, x1, ref y1);
dforest.dfprocess(df1, x2, ref y2);
allsame = true;
for(i=0; i<=nclasses-1; i++)
{
allsame = allsame & (double)(y1[i])==(double)(y2[i]);
}
err = err | !allsame;
//
// Same inputs on original forest leads to same outputs
// on copy created using DFCopy
//
unsetdf(df2);
dforest.dfcopy(df1, df2);
for(i=0; i<=nvars-1; i++)
{
x1[i] = 2*math.randomreal()-1;
x2[i] = x1[i];
}
for(i=0; i<=nclasses-1; i++)
{
y1[i] = 2*math.randomreal()-1;
y2[i] = 2*math.randomreal()-1;
}
dforest.dfprocess(df1, x1, ref y1);
dforest.dfprocess(df2, x2, ref y2);
allsame = true;
for(i=0; i<=nclasses-1; i++)
{
allsame = allsame & (double)(y1[i])==(double)(y2[i]);
}
err = err | !allsame;
//
// Same inputs on original forest leads to same outputs
// on copy created using DFSerialize
//
unsetdf(df2);
{
//
// This code passes data structure through serializers
// (serializes it to string and loads back)
//
serializer _local_serializer;
string _local_str;
_local_serializer = new serializer();
_local_serializer.alloc_start();
dforest.dfalloc(_local_serializer, df1);
_local_serializer.sstart_str();
dforest.dfserialize(_local_serializer, df1);
_local_serializer.stop();
_local_str = _local_serializer.get_string();
_local_serializer = new serializer();
_local_serializer.ustart_str(_local_str);
dforest.dfunserialize(_local_serializer, df2);
_local_serializer.stop();
}
for(i=0; i<=nvars-1; i++)
{
x1[i] = 2*math.randomreal()-1;
x2[i] = x1[i];
}
for(i=0; i<=nclasses-1; i++)
{
y1[i] = 2*math.randomreal()-1;
y2[i] = 2*math.randomreal()-1;
}
dforest.dfprocess(df1, x1, ref y1);
dforest.dfprocess(df2, x2, ref y2);
allsame = true;
for(i=0; i<=nclasses-1; i++)
{
allsame = allsame & (double)(y1[i])==(double)(y2[i]);
}
err = err | !allsame;
//
// Normalization properties
//
if( nclasses>1 )
{
for(i=0; i<=nvars-1; i++)
{
x1[i] = 2*math.randomreal()-1;
}
dforest.dfprocess(df1, x1, ref y1);
v = 0;
for(i=0; i<=nclasses-1; i++)
{
v = v+y1[i];
err = err | (double)(y1[i])<(double)(0);
}
err = err | (double)(Math.Abs(v-1))>(double)(1000*math.machineepsilon);
}
}
}
/*************************************************************************
* Basic test: extended variable selection leads to better results.
*
* Next task CAN be solved without EVS but it is very unlikely. With EVS
* it can be easily and exactly solved.
*
* Task matrix:
* 1 0 0 0 ... 0 0
* 0 1 0 0 ... 0 1
* 0 0 1 0 ... 0 2
* 0 0 0 1 ... 0 3
* 0 0 0 0 ... 1 N-1
*************************************************************************/
private static void basictest5(ref bool err)
{
double[,] xy = new double[0, 0];
int nvars = 0;
int npoints = 0;
int nfeatures = 0;
int nsample = 0;
int ntrees = 0;
int evs = 0;
int i = 0;
int j = 0;
bool eflag = new bool();
int info = 0;
dforest.decisionforest df = new dforest.decisionforest();
double[] x = new double[0];
double[] y = new double[0];
dforest.dfreport rep = new dforest.dfreport();
int i_ = 0;
//
// select npoints and ntrees
//
npoints = 50;
nvars = npoints;
ntrees = 1;
nsample = npoints;
evs = 2;
nfeatures = 1;
//
// Prepare task
//
xy = new double[npoints - 1 + 1, nvars + 1];
x = new double[nvars - 1 + 1];
y = new double[0 + 1];
for (i = 0; i <= npoints - 1; i++)
{
for (j = 0; j <= nvars - 1; j++)
{
xy[i, j] = 0;
}
xy[i, i] = 1;
xy[i, nvars] = i;
}
//
// Without EVS
//
dforest.dfbuildinternal(ref xy, npoints, nvars, 1, ntrees, nsample, nfeatures, 0, ref info, ref df, ref rep);
if (info <= 0)
{
err = true;
return;
}
eflag = false;
for (i = 0; i <= npoints - 1; i++)
{
for (i_ = 0; i_ <= nvars - 1; i_++)
{
x[i_] = xy[i, i_];
}
dforest.dfprocess(ref df, ref x, ref y);
if ((double)(Math.Abs(y[0] - xy[i, nvars])) > (double)(1000 * AP.Math.MachineEpsilon))
{
eflag = true;
}
}
if (!eflag)
{
err = true;
return;
}
//
// With EVS
//
dforest.dfbuildinternal(ref xy, npoints, nvars, 1, ntrees, nsample, nfeatures, evs, ref info, ref df, ref rep);
if (info <= 0)
{
err = true;
return;
}
eflag = false;
for (i = 0; i <= npoints - 1; i++)
{
for (i_ = 0; i_ <= nvars - 1; i_++)
{
x[i_] = xy[i, i_];
}
dforest.dfprocess(ref df, ref x, ref y);
if ((double)(Math.Abs(y[0] - xy[i, nvars])) > (double)(1000 * AP.Math.MachineEpsilon))
{
eflag = true;
}
}
if (eflag)
{
err = true;
return;
}
}
/*************************************************************************
* Basic test: simple regression task without noise:
* |x|<1, |y|<1
* F(x,y) = x^2+y
*************************************************************************/
private static void basictest4(ref bool err)
{
int pass = 0;
int passcount = 0;
double[,] xy = new double[0, 0];
int npoints = 0;
int ntrees = 0;
int ns = 0;
int strongc = 0;
int i = 0;
int j = 0;
int k = 0;
double s = 0;
int info = 0;
dforest.decisionforest df = new dforest.decisionforest();
dforest.decisionforest df2 = new dforest.decisionforest();
double[] x = new double[0];
double[] y = new double[0];
dforest.dfreport rep = new dforest.dfreport();
dforest.dfreport rep2 = new dforest.dfreport();
int testgridsize = 0;
double maxerr = 0;
double maxerr2 = 0;
double avgerr = 0;
double avgerr2 = 0;
int cnt = 0;
double ey = 0;
passcount = 1;
testgridsize = 50;
for (pass = 1; pass <= passcount; pass++)
{
//
// select npoints and ntrees
//
npoints = 5000;
ntrees = 100;
ns = (int)Math.Round(0.1 * npoints);
strongc = 1;
//
// Prepare task
//
xy = new double[npoints - 1 + 1, 2 + 1];
x = new double[1 + 1];
y = new double[0 + 1];
for (i = 0; i <= npoints - 1; i++)
{
xy[i, 0] = 2 * AP.Math.RandomReal() - 1;
xy[i, 1] = 2 * AP.Math.RandomReal() - 1;
xy[i, 2] = AP.Math.Sqr(xy[i, 0]) + xy[i, 1];
}
//
// Test
//
dforest.dfbuildinternal(ref xy, npoints, 2, 1, ntrees, ns, 1, 0, ref info, ref df, ref rep);
if (info <= 0)
{
err = true;
return;
}
dforest.dfbuildinternal(ref xy, npoints, 2, 1, ntrees, ns, 1, strongc, ref info, ref df2, ref rep2);
if (info <= 0)
{
err = true;
return;
}
maxerr = 0;
maxerr2 = 0;
avgerr = 0;
avgerr2 = 0;
cnt = 0;
for (i = (int)Math.Round(-(0.7 * testgridsize / 2)); i <= (int)Math.Round(0.7 * testgridsize / 2); i++)
{
for (j = (int)Math.Round(-(0.7 * testgridsize / 2)); j <= (int)Math.Round(0.7 * testgridsize / 2); j++)
{
x[0] = (double)(i) / ((double)(testgridsize / 2));
x[1] = (double)(j) / ((double)(testgridsize / 2));
ey = AP.Math.Sqr(x[0]) + x[1];
dforest.dfprocess(ref df, ref x, ref y);
maxerr = Math.Max(maxerr, Math.Abs(y[0] - ey));
avgerr = avgerr + Math.Abs(y[0] - ey);
dforest.dfprocess(ref df2, ref x, ref y);
maxerr2 = Math.Max(maxerr2, Math.Abs(y[0] - ey));
avgerr2 = avgerr2 + Math.Abs(y[0] - ey);
cnt = cnt + 1;
}
}
avgerr = avgerr / cnt;
avgerr2 = avgerr2 / cnt;
err = err | (double)(maxerr) > (double)(0.2);
err = err | (double)(maxerr2) > (double)(0.2);
err = err | (double)(avgerr) > (double)(0.1);
err = err | (double)(avgerr2) > (double)(0.1);
}
}
/*************************************************************************
* Basic test: tests generalization ability on a simple classification task
* (no noise):
* |x|<1, |y|<1
* x^2+y^2<=0.25 - P(class=0)=1
* x^2+y^2>0.25 - P(class=0)=0
*************************************************************************/
private static void basictest3(ref bool err)
{
int pass = 0;
int passcount = 0;
double[,] xy = new double[0, 0];
int npoints = 0;
int ntrees = 0;
int i = 0;
int j = 0;
int k = 0;
double s = 0;
int info = 0;
dforest.decisionforest df = new dforest.decisionforest();
double[] x = new double[0];
double[] y = new double[0];
dforest.dfreport rep = new dforest.dfreport();
int testgridsize = 0;
double r = 0;
passcount = 1;
testgridsize = 50;
for (pass = 1; pass <= passcount; pass++)
{
//
// select npoints and ntrees
//
npoints = 2000;
ntrees = 100;
//
// Prepare task
//
xy = new double[npoints - 1 + 1, 2 + 1];
x = new double[1 + 1];
y = new double[1 + 1];
for (i = 0; i <= npoints - 1; i++)
{
xy[i, 0] = 2 * AP.Math.RandomReal() - 1;
xy[i, 1] = 2 * AP.Math.RandomReal() - 1;
if ((double)(AP.Math.Sqr(xy[i, 0]) + AP.Math.Sqr(xy[i, 1])) <= (double)(0.25))
{
xy[i, 2] = 0;
}
else
{
xy[i, 2] = 1;
}
}
//
// Test
//
dforest.dfbuildinternal(ref xy, npoints, 2, 2, ntrees, (int)Math.Round(0.1 * npoints), 1, 0, ref info, ref df, ref rep);
if (info <= 0)
{
err = true;
return;
}
for (i = -(testgridsize / 2); i <= testgridsize / 2; i++)
{
for (j = -(testgridsize / 2); j <= testgridsize / 2; j++)
{
x[0] = (double)(i) / ((double)(testgridsize / 2));
x[1] = (double)(j) / ((double)(testgridsize / 2));
dforest.dfprocess(ref df, ref x, ref y);
//
// Test for basic properties
//
s = 0;
for (k = 0; k <= 1; k++)
{
if ((double)(y[k]) < (double)(0))
{
err = true;
return;
}
s = s + y[k];
}
if ((double)(Math.Abs(s - 1)) > (double)(1000 * AP.Math.MachineEpsilon))
{
err = true;
return;
}
//
// test for good correlation with results
//
r = Math.Sqrt(AP.Math.Sqr(x[0]) + AP.Math.Sqr(x[1]));
if ((double)(r) < (double)(0.5 * 0.5))
{
err = err | (double)(y[0]) < (double)(0.6);
}
if ((double)(r) > (double)(0.5 * 1.5))
{
err = err | (double)(y[1]) < (double)(0.6);
}
}
}
}
}
/*************************************************************************
* Basic test: tests generalization ability on a simple noisy classification
* task:
* 0<x<1 - P(class=0)=1
* 1<x<2 - P(class=0)=2-x
* 2<x<3 - P(class=0)=0
*************************************************************************/
private static void basictest2(ref bool err)
{
int pass = 0;
int passcount = 0;
double[,] xy = new double[0, 0];
int npoints = 0;
int ntrees = 0;
int i = 0;
int j = 0;
double s = 0;
int info = 0;
dforest.decisionforest df = new dforest.decisionforest();
double[] x = new double[0];
double[] y = new double[0];
dforest.dfreport rep = new dforest.dfreport();
bool hassame = new bool();
passcount = 1;
for (pass = 1; pass <= passcount; pass++)
{
//
// select npoints and ntrees
//
npoints = 3000;
ntrees = 50;
//
// Prepare task
//
xy = new double[npoints - 1 + 1, 1 + 1];
x = new double[0 + 1];
y = new double[1 + 1];
for (i = 0; i <= npoints - 1; i++)
{
xy[i, 0] = 3 * AP.Math.RandomReal();
if ((double)(xy[i, 0]) <= (double)(1))
{
xy[i, 1] = 0;
}
else
{
if ((double)(xy[i, 0]) <= (double)(2))
{
if ((double)(AP.Math.RandomReal()) < (double)(xy[i, 0] - 1))
{
xy[i, 1] = 1;
}
else
{
xy[i, 1] = 0;
}
}
else
{
xy[i, 1] = 1;
}
}
}
//
// Test
//
dforest.dfbuildinternal(ref xy, npoints, 1, 2, ntrees, (int)Math.Round(0.05 * npoints), 1, 0, ref info, ref df, ref rep);
if (info <= 0)
{
err = true;
return;
}
x[0] = 0.0;
while ((double)(x[0]) <= (double)(3.0))
{
dforest.dfprocess(ref df, ref x, ref y);
//
// Test for basic properties
//
s = 0;
for (j = 0; j <= 1; j++)
{
if ((double)(y[j]) < (double)(0))
{
err = true;
return;
}
s = s + y[j];
}
if ((double)(Math.Abs(s - 1)) > (double)(1000 * AP.Math.MachineEpsilon))
{
err = true;
return;
}
//
// test for good correlation with results
//
if ((double)(x[0]) < (double)(1))
{
err = err | (double)(y[0]) < (double)(0.8);
}
if ((double)(x[0]) >= (double)(1) & (double)(x[0]) <= (double)(2))
{
err = err | (double)(Math.Abs(y[1] - (x[0] - 1))) > (double)(0.5);
}
if ((double)(x[0]) > (double)(2))
{
err = err | (double)(y[1]) < (double)(0.8);
}
x[0] = x[0] + 0.01;
}
}
}
/*************************************************************************
* Basic test: one-tree forest built using full sample must remember all the
* training cases
*************************************************************************/
private static void basictest1(int nvars,
int nclasses,
int passcount,
ref bool err)
{
int pass = 0;
double[,] xy = new double[0, 0];
int npoints = 0;
int i = 0;
int j = 0;
int k = 0;
double s = 0;
int info = 0;
dforest.decisionforest df = new dforest.decisionforest();
double[] x = new double[0];
double[] y = new double[0];
dforest.dfreport rep = new dforest.dfreport();
bool hassame = new bool();
int i_ = 0;
if (nclasses == 1)
{
//
// only classification tasks
//
return;
}
for (pass = 1; pass <= passcount; pass++)
{
//
// select number of points
//
if (pass <= 3 & passcount > 3)
{
npoints = pass;
}
else
{
npoints = 100 + AP.Math.RandomInteger(100);
}
//
// Prepare task
//
xy = new double[npoints - 1 + 1, nvars + 1];
x = new double[nvars - 1 + 1];
y = new double[nclasses - 1 + 1];
for (i = 0; i <= npoints - 1; i++)
{
for (j = 0; j <= nvars - 1; j++)
{
xy[i, j] = 2 * AP.Math.RandomReal() - 1;
}
xy[i, nvars] = AP.Math.RandomInteger(nclasses);
}
//
// Test
//
dforest.dfbuildinternal(ref xy, npoints, nvars, nclasses, 1, npoints, 1, 1, ref info, ref df, ref rep);
if (info <= 0)
{
err = true;
return;
}
for (i = 0; i <= npoints - 1; i++)
{
for (i_ = 0; i_ <= nvars - 1; i_++)
{
x[i_] = xy[i, i_];
}
dforest.dfprocess(ref df, ref x, ref y);
s = 0;
for (j = 0; j <= nclasses - 1; j++)
{
if ((double)(y[j]) < (double)(0))
{
err = true;
return;
}
s = s + y[j];
}
if ((double)(Math.Abs(s - 1)) > (double)(1000 * AP.Math.MachineEpsilon))
{
err = true;
return;
}
if ((double)(Math.Abs(y[(int)Math.Round(xy[i, nvars])] - 1)) > (double)(1000 * AP.Math.MachineEpsilon))
{
//
// not an error if there exists such K,J that XY[K,J]=XY[I,J]
// (may be we just can't distinguish two tied values).
//
// definitely error otherwise.
//
hassame = false;
for (k = 0; k <= npoints - 1; k++)
{
if (k != i)
{
for (j = 0; j <= nvars - 1; j++)
{
if ((double)(xy[k, j]) == (double)(xy[i, j]))
{
hassame = true;
}
}
}
}
if (!hassame)
{
err = true;
return;
}
}
}
}
}
/*************************************************************************
* Processing functions test
*************************************************************************/
private static void testprocessing(ref bool err)
{
int nvars = 0;
int nclasses = 0;
int nsample = 0;
int ntrees = 0;
int nfeatures = 0;
int flags = 0;
dforest.decisionforest df1 = new dforest.decisionforest();
dforest.decisionforest df2 = new dforest.decisionforest();
int npoints = 0;
double[,] xy = new double[0, 0];
int pass = 0;
int passcount = 0;
int i = 0;
int j = 0;
bool allsame = new bool();
int rlen = 0;
int info = 0;
dforest.dfreport rep = new dforest.dfreport();
double[] x1 = new double[0];
double[] x2 = new double[0];
double[] y1 = new double[0];
double[] y2 = new double[0];
double[] ra = new double[0];
double[] ra2 = new double[0];
double v = 0;
passcount = 100;
//
// Main cycle
//
for (pass = 1; pass <= passcount; pass++)
{
//
// initialize parameters
//
nvars = 1 + AP.Math.RandomInteger(5);
nclasses = 1 + AP.Math.RandomInteger(3);
ntrees = 1 + AP.Math.RandomInteger(4);
nfeatures = 1 + AP.Math.RandomInteger(nvars);
flags = 0;
if ((double)(AP.Math.RandomReal()) > (double)(0.5))
{
flags = flags + 2;
}
//
// Initialize arrays and data
//
npoints = 10 + AP.Math.RandomInteger(50);
nsample = Math.Max(10, AP.Math.RandomInteger(npoints));
x1 = new double[nvars - 1 + 1];
x2 = new double[nvars - 1 + 1];
y1 = new double[nclasses - 1 + 1];
y2 = new double[nclasses - 1 + 1];
xy = new double[npoints - 1 + 1, nvars + 1];
for (i = 0; i <= npoints - 1; i++)
{
for (j = 0; j <= nvars - 1; j++)
{
if (j % 2 == 0)
{
xy[i, j] = 2 * AP.Math.RandomReal() - 1;
}
else
{
xy[i, j] = AP.Math.RandomInteger(2);
}
}
if (nclasses == 1)
{
xy[i, nvars] = 2 * AP.Math.RandomReal() - 1;
}
else
{
xy[i, nvars] = AP.Math.RandomInteger(nclasses);
}
}
//
// create forest
//
dforest.dfbuildinternal(ref xy, npoints, nvars, nclasses, ntrees, nsample, nfeatures, flags, ref info, ref df1, ref rep);
if (info <= 0)
{
err = true;
return;
}
//
// Same inputs leads to same outputs
//
for (i = 0; i <= nvars - 1; i++)
{
x1[i] = 2 * AP.Math.RandomReal() - 1;
x2[i] = x1[i];
}
for (i = 0; i <= nclasses - 1; i++)
{
y1[i] = 2 * AP.Math.RandomReal() - 1;
y2[i] = 2 * AP.Math.RandomReal() - 1;
}
dforest.dfprocess(ref df1, ref x1, ref y1);
dforest.dfprocess(ref df1, ref x2, ref y2);
allsame = true;
for (i = 0; i <= nclasses - 1; i++)
{
allsame = allsame & (double)(y1[i]) == (double)(y2[i]);
}
err = err | !allsame;
//
// Same inputs on original forest leads to same outputs
// on copy created using DFCopy
//
unsetdf(ref df2);
dforest.dfcopy(ref df1, ref df2);
for (i = 0; i <= nvars - 1; i++)
{
x1[i] = 2 * AP.Math.RandomReal() - 1;
x2[i] = x1[i];
}
for (i = 0; i <= nclasses - 1; i++)
{
y1[i] = 2 * AP.Math.RandomReal() - 1;
y2[i] = 2 * AP.Math.RandomReal() - 1;
}
dforest.dfprocess(ref df1, ref x1, ref y1);
dforest.dfprocess(ref df2, ref x2, ref y2);
allsame = true;
for (i = 0; i <= nclasses - 1; i++)
{
allsame = allsame & (double)(y1[i]) == (double)(y2[i]);
}
err = err | !allsame;
//
// Same inputs on original forest leads to same outputs
// on copy created using DFSerialize
//
unsetdf(ref df2);
ra = new double[0 + 1];
ra[0] = 0;
rlen = 0;
dforest.dfserialize(ref df1, ref ra, ref rlen);
ra2 = new double[rlen - 1 + 1];
for (i = 0; i <= rlen - 1; i++)
{
ra2[i] = ra[i];
}
dforest.dfunserialize(ref ra2, ref df2);
for (i = 0; i <= nvars - 1; i++)
{
x1[i] = 2 * AP.Math.RandomReal() - 1;
x2[i] = x1[i];
}
for (i = 0; i <= nclasses - 1; i++)
{
y1[i] = 2 * AP.Math.RandomReal() - 1;
y2[i] = 2 * AP.Math.RandomReal() - 1;
}
dforest.dfprocess(ref df1, ref x1, ref y1);
dforest.dfprocess(ref df2, ref x2, ref y2);
allsame = true;
for (i = 0; i <= nclasses - 1; i++)
{
allsame = allsame & (double)(y1[i]) == (double)(y2[i]);
}
err = err | !allsame;
//
// Normalization properties
//
if (nclasses > 1)
{
for (i = 0; i <= nvars - 1; i++)
{
x1[i] = 2 * AP.Math.RandomReal() - 1;
}
dforest.dfprocess(ref df1, ref x1, ref y1);
v = 0;
for (i = 0; i <= nclasses - 1; i++)
{
v = v + y1[i];
err = err | (double)(y1[i]) < (double)(0);
}
err = err | (double)(Math.Abs(v - 1)) > (double)(1000 * AP.Math.MachineEpsilon);
}
}
}
