public override alglib.apobject make_copy()
{
mlpparallelizationcv _result = new mlpparallelizationcv();
_result.network = (mlpbase.multilayerperceptron)network.make_copy();
_result.rep = (mlpreport)rep.make_copy();
_result.subset = (int[])subset.Clone();
_result.subsetsize = subsetsize;
_result.xyrow = (double[])xyrow.Clone();
_result.y = (double[])y.Clone();
_result.ngrad = ngrad;
_result.trnpool = (alglib.smp.shared_pool)trnpool.make_copy();
return _result;
}
/*************************************************************************
This function estimates generalization error using cross-validation on the
current dataset with current training settings.
FOR USERS OF COMMERCIAL EDITION:
! Commercial version of ALGLIB includes two important improvements of
! this function:
! * multicore support (C++ and C# computational cores)
! * SSE support (C++ computational core)
!
! Second improvement gives constant speedup (2-3X). First improvement
! gives close-to-linear speedup on multicore systems. Following
! operations can be executed in parallel:
! * FoldsCount cross-validation rounds (always)
! * NRestarts training sessions performed within each of
! cross-validation rounds (if NRestarts>1)
! * gradient calculation over large dataset (if dataset is large enough)
!
! In order to use multicore features you have to:
! * use commercial version of ALGLIB
! * call this function with "smp_" prefix, which indicates that
! multicore code will be used (for multicore support)
!
! In order to use SSE features you have to:
! * use commercial version of ALGLIB on Intel processors
! * use C++ computational core
!
! This note is given for users of commercial edition; if you use GPL
! edition, you still will be able to call smp-version of this function,
! but all computations will be done serially.
!
! We recommend you to carefully read ALGLIB Reference Manual, section
! called 'SMP support', before using parallel version of this function.
INPUT PARAMETERS:
S - trainer object
Network - neural network. It must have same number of inputs and
output/classes as was specified during creation of the
trainer object. Network is not changed during cross-
validation and is not trained - it is used only as
representative of its architecture. I.e., we estimate
generalization properties of ARCHITECTURE, not some
specific network.
NRestarts - number of restarts, >=0:
* NRestarts>0 means that for each cross-validation
round specified number of random restarts is
performed, with best network being chosen after
training.
* NRestarts=0 is same as NRestarts=1
FoldsCount - number of folds in k-fold cross-validation:
* 2<=FoldsCount<=size of dataset
* recommended value: 10.
* values larger than dataset size will be silently
truncated down to dataset size
OUTPUT PARAMETERS:
Rep - structure which contains cross-validation estimates:
* Rep.RelCLSError - fraction of misclassified cases.
* Rep.AvgCE - acerage cross-entropy
* Rep.RMSError - root-mean-square error
* Rep.AvgError - average error
* Rep.AvgRelError - average relative error
NOTE: when no dataset was specified with MLPSetDataset/SetSparseDataset(),
or subset with only one point was given, zeros are returned as
estimates.
NOTE: this method performs FoldsCount cross-validation rounds, each one
with NRestarts random starts. Thus, FoldsCount*NRestarts networks
are trained in total.
NOTE: Rep.RelCLSError/Rep.AvgCE are zero on regression problems.
NOTE: on classification problems Rep.RMSError/Rep.AvgError/Rep.AvgRelError
contain errors in prediction of posterior probabilities.
-- ALGLIB --
Copyright 23.07.2012 by Bochkanov Sergey
*************************************************************************/
public static void mlpkfoldcv(mlptrainer s,
mlpbase.multilayerperceptron network,
int nrestarts,
int foldscount,
mlpreport rep)
{
alglib.smp.shared_pool pooldatacv = new alglib.smp.shared_pool();
mlpparallelizationcv datacv = new mlpparallelizationcv();
mlpparallelizationcv sdatacv = null;
double[,] cvy = new double[0,0];
int[] folds = new int[0];
double[] buf = new double[0];
double[] dy = new double[0];
int nin = 0;
int nout = 0;
int wcount = 0;
int rowsize = 0;
int ntype = 0;
int ttype = 0;
int i = 0;
int j = 0;
int k = 0;
hqrnd.hqrndstate rs = new hqrnd.hqrndstate();
int i_ = 0;
int i1_ = 0;
if( !mlpbase.mlpissoftmax(network) )
{
ntype = 0;
}
else
{
ntype = 1;
}
if( s.rcpar )
{
ttype = 0;
}
else
{
ttype = 1;
}
alglib.ap.assert(ntype==ttype, "MLPKFoldCV: type of input network is not similar to network type in trainer object");
alglib.ap.assert(s.npoints>=0, "MLPKFoldCV: possible trainer S is not initialized(S.NPoints<0)");
mlpbase.mlpproperties(network, ref nin, ref nout, ref wcount);
alglib.ap.assert(s.nin==nin, "MLPKFoldCV: number of inputs in trainer is not equal to number of inputs in network");
alglib.ap.assert(s.nout==nout, "MLPKFoldCV: number of outputs in trainer is not equal to number of outputs in network");
alglib.ap.assert(nrestarts>=0, "MLPKFoldCV: NRestarts<0");
alglib.ap.assert(foldscount>=2, "MLPKFoldCV: FoldsCount<2");
if( foldscount>s.npoints )
{
foldscount = s.npoints;
}
rep.relclserror = 0;
rep.avgce = 0;
rep.rmserror = 0;
rep.avgerror = 0;
rep.avgrelerror = 0;
hqrnd.hqrndrandomize(rs);
rep.ngrad = 0;
rep.nhess = 0;
rep.ncholesky = 0;
if( s.npoints==0 || s.npoints==1 )
{
return;
}
//
// Read network geometry, test parameters
//
if( s.rcpar )
{
rowsize = nin+nout;
dy = new double[nout];
bdss.dserrallocate(-nout, ref buf);
}
else
{
rowsize = nin+1;
dy = new double[1];
bdss.dserrallocate(nout, ref buf);
}
//
// Folds
//
folds = new int[s.npoints];
for(i=0; i<=s.npoints-1; i++)
{
folds[i] = i*foldscount/s.npoints;
}
for(i=0; i<=s.npoints-2; i++)
{
j = i+hqrnd.hqrnduniformi(rs, s.npoints-i);
if( j!=i )
{
k = folds[i];
folds[i] = folds[j];
folds[j] = k;
}
}
cvy = new double[s.npoints, nout];
//
// Initialize SEED-value for shared pool
//
datacv.ngrad = 0;
mlpbase.mlpcopy(network, datacv.network);
datacv.subset = new int[s.npoints];
datacv.xyrow = new double[rowsize];
datacv.y = new double[nout];
//
// Create shared pool
//
alglib.smp.ae_shared_pool_set_seed(pooldatacv, datacv);
//
// Parallelization
//
mthreadcv(s, rowsize, nrestarts, folds, 0, foldscount, cvy, pooldatacv);
//
// Calculate value for NGrad
//
alglib.smp.ae_shared_pool_first_recycled(pooldatacv, ref sdatacv);
while( sdatacv!=null )
{
rep.ngrad = rep.ngrad+sdatacv.ngrad;
alglib.smp.ae_shared_pool_next_recycled(pooldatacv, ref sdatacv);
}
//
// Connect of results and calculate cross-validation error
//
for(i=0; i<=s.npoints-1; i++)
{
if( s.datatype==0 )
{
for(i_=0; i_<=rowsize-1;i_++)
{
datacv.xyrow[i_] = s.densexy[i,i_];
}
}
if( s.datatype==1 )
{
sparse.sparsegetrow(s.sparsexy, i, ref datacv.xyrow);
}
for(i_=0; i_<=nout-1;i_++)
{
datacv.y[i_] = cvy[i,i_];
}
if( s.rcpar )
{
i1_ = (nin) - (0);
for(i_=0; i_<=nout-1;i_++)
{
dy[i_] = datacv.xyrow[i_+i1_];
}
}
else
{
dy[0] = datacv.xyrow[nin];
}
bdss.dserraccumulate(ref buf, datacv.y, dy);
}
bdss.dserrfinish(ref buf);
rep.relclserror = buf[0];
rep.avgce = buf[1];
rep.rmserror = buf[2];
rep.avgerror = buf[3];
rep.avgrelerror = buf[4];
}
public override alglib.apobject make_copy()
{
mlpparallelizationcv _result = new mlpparallelizationcv();
_result.network = (mlpbase.multilayerperceptron)network.make_copy();
_result.tnetwork = (mlpbase.multilayerperceptron)tnetwork.make_copy();
_result.state = (minlbfgs.minlbfgsstate)state.make_copy();
_result.rep = (mlpreport)rep.make_copy();
_result.subset = (int[])subset.Clone();
_result.subsetsize = subsetsize;
_result.xyrow = (double[])xyrow.Clone();
_result.y = (double[])y.Clone();
_result.ngrad = ngrad;
_result.bufwbest = (double[])bufwbest.Clone();
_result.bufwfinal = (double[])bufwfinal.Clone();
return _result;
}
