{

AnnParams()

{

termCrit = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 1000, 0.01 );

trainMethod = ANN_MLP::RPROP;

bpDWScale = bpMomentScale = 0.1;

rpDW0 = 0.1; rpDWPlus = 1.2; rpDWMinus = 0.5;

rpDWMin = FLT_EPSILON; rpDWMax = 50.;

initialT=10;finalT=0.1,coolingRatio=0.95;itePerStep=10;

rEnergy = cv::RNG(12345);

}

TermCriteria termCrit;

int trainMethod;

double bpDWScale;

double bpMomentScale;

double rpDW0;

double rpDWPlus;

double rpDWMinus;

double rpDWMin;

double rpDWMax;

double initialT;

double finalT;

double coolingRatio;

int itePerStep;

RNG rEnergy;

{

ml::ANN_MLP& nn;

Ptr<ml::TrainData> data;

int nbVariables;

vector<double*> adrVariables;

RNG rVar;

RNG rIndex;

double varTmp;

int index;

SimulatedAnnealingANN_MLP(ml::ANN_MLP& x, const Ptr<ml::TrainData>& d) : nn(x), data(d)

{

initVarMap();

}

~SimulatedAnnealingANN_MLP() {}

void changeState()

{

index = rIndex.uniform(0, nbVariables);

double dv = rVar.uniform(-1.0, 1.0);

varTmp = *adrVariables[index];

*adrVariables[index] = dv;

}

void reverseState()

{

*adrVariables[index] = varTmp;

}

double energy() const { return nn.calcError(data, false, noArray()); }

void initVarMap()

{

Mat l = nn.getLayerSizes();

nbVariables = 0;

adrVariables.clear();

for (int i = 1; i < l.rows-1; i++)

{

Mat w = nn.getWeights(i);

for (int j = 0; j < w.rows; j++)

{

for (int k = 0; k < w.cols; k++, nbVariables++)

{

if (j == w.rows - 1)

{

adrVariables.push_back(&w.at<double>(w.rows - 1, k));

}

else

{

adrVariables.push_back(&w.at<double>(j, k));

}

}

}

}

}

{

const ANN_MLP_ANNEAL* this_ = dynamic_cast<const ANN_MLP_ANNEAL*>(this);

if (!this_)

CV_Error(Error::StsNotImplemented, "the class is not ANN_MLP_ANNEAL");

return this_->getAnnealInitialT();

{

ANN_MLP_ANNEAL* this_ = dynamic_cast<ANN_MLP_ANNEAL*>(this);

if (!this_)

CV_Error(Error::StsNotImplemented, "the class is not ANN_MLP_ANNEAL");

this_->setAnnealInitialT(val);

{

const ANN_MLP_ANNEAL* this_ = dynamic_cast<const ANN_MLP_ANNEAL*>(this);

if (!this_)

CV_Error(Error::StsNotImplemented, "the class is not ANN_MLP_ANNEAL");

return this_->getAnnealFinalT();

{

ANN_MLP_ANNEAL* this_ = dynamic_cast<ANN_MLP_ANNEAL*>(this);

if (!this_)

CV_Error(Error::StsNotImplemented, "the class is not ANN_MLP_ANNEAL");

this_->setAnnealFinalT(val);

{

const ANN_MLP_ANNEAL* this_ = dynamic_cast<const ANN_MLP_ANNEAL*>(this);

if (!this_)

CV_Error(Error::StsNotImplemented, "the class is not ANN_MLP_ANNEAL");

return this_->getAnnealCoolingRatio();

{

ANN_MLP_ANNEAL* this_ = dynamic_cast<ANN_MLP_ANNEAL*>(this);

if (!this_)

CV_Error(Error::StsNotImplemented, "the class is not ANN_MLP_ANNEAL");

this_->setAnnealCoolingRatio(val);

{

const ANN_MLP_ANNEAL* this_ = dynamic_cast<const ANN_MLP_ANNEAL*>(this);

if (!this_)

CV_Error(Error::StsNotImplemented, "the class is not ANN_MLP_ANNEAL");

return this_->getAnnealItePerStep();

{

ANN_MLP_ANNEAL* this_ = dynamic_cast<ANN_MLP_ANNEAL*>(this);

if (!this_)

CV_Error(Error::StsNotImplemented, "the class is not ANN_MLP_ANNEAL");

this_->setAnnealItePerStep(val);

{

ANN_MLP_ANNEAL* this_ = dynamic_cast<ANN_MLP_ANNEAL*>(this);

if (!this_)

CV_Error(Error::StsNotImplemented, "the class is not ANN_MLP_ANNEAL");

this_->setAnnealEnergyRNG(rng);

{

ANN_MLPImpl()

{

clear();

setActivationFunction( SIGMOID_SYM, 0, 0);

setLayerSizes(Mat());

setTrainMethod(ANN_MLP::RPROP, 0.1, FLT_EPSILON);

}

virtual ~ANN_MLPImpl() {}

CV_IMPL_PROPERTY(TermCriteria, TermCriteria, params.termCrit)

CV_IMPL_PROPERTY(double, BackpropWeightScale, params.bpDWScale)

CV_IMPL_PROPERTY(double, BackpropMomentumScale, params.bpMomentScale)

CV_IMPL_PROPERTY(double, RpropDW0, params.rpDW0)

CV_IMPL_PROPERTY(double, RpropDWPlus, params.rpDWPlus)

CV_IMPL_PROPERTY(double, RpropDWMinus, params.rpDWMinus)

CV_IMPL_PROPERTY(double, RpropDWMin, params.rpDWMin)

CV_IMPL_PROPERTY(double, RpropDWMax, params.rpDWMax)

CV_IMPL_PROPERTY(double, AnnealInitialT, params.initialT)

CV_IMPL_PROPERTY(double, AnnealFinalT, params.finalT)

CV_IMPL_PROPERTY(double, AnnealCoolingRatio, params.coolingRatio)

CV_IMPL_PROPERTY(int, AnnealItePerStep, params.itePerStep)

//CV_IMPL_PROPERTY(RNG, AnnealEnergyRNG, params.rEnergy)

inline void setAnnealEnergyRNG(const RNG& val) { params.rEnergy = val; }

void clear()

{

min_val = max_val = min_val1 = max_val1 = 0.;

rng = RNG((uint64)-1);

weights.clear();

trained = false;

max_buf_sz = 1 << 12;

}

int layer_count() const { return (int)layer_sizes.size(); }

void setTrainMethod(int method, double param1, double param2)

{

if (method != ANN_MLP::RPROP && method != ANN_MLP::BACKPROP && method != ANN_MLP::ANNEAL)

method = ANN_MLP::RPROP;

params.trainMethod = method;

if(method == ANN_MLP::RPROP )

{

if( param1 < FLT_EPSILON )

param1 = 1.;

params.rpDW0 = param1;

params.rpDWMin = std::max( param2, 0. );

}

else if (method == ANN_MLP::BACKPROP)

{

if (param1 <= 0)

param1 = 0.1;

params.bpDWScale = inBounds<double>(param1, 1e-3, 1.);

if (param2 < 0)

param2 = 0.1;

params.bpMomentScale = std::min(param2, 1.);

}

}

int getTrainMethod() const

{

return params.trainMethod;

}

void setActivationFunction(int _activ_func, double _f_param1, double _f_param2)

{

if( _activ_func < 0 || _activ_func > LEAKYRELU)

CV_Error( CV_StsOutOfRange, "Unknown activation function" );

activ_func = _activ_func;

switch( activ_func )

{

case SIGMOID_SYM:

max_val = 0.95; min_val = -max_val;

max_val1 = 0.98; min_val1 = -max_val1;

if( fabs(_f_param1) < FLT_EPSILON )

_f_param1 = 2./3;

if( fabs(_f_param2) < FLT_EPSILON )

_f_param2 = 1.7159;

break;

case GAUSSIAN:

max_val = 1.; min_val = 0.05;

max_val1 = 1.; min_val1 = 0.02;

if (fabs(_f_param1) < FLT_EPSILON)

_f_param1 = 1.;

if (fabs(_f_param2) < FLT_EPSILON)

_f_param2 = 1.;

break;

case RELU:

if (fabs(_f_param1) < FLT_EPSILON)

_f_param1 = 1;

min_val = max_val = min_val1 = max_val1 = 0.;

_f_param2 = 0.;

break;

case LEAKYRELU:

if (fabs(_f_param1) < FLT_EPSILON)

_f_param1 = 0.01;

min_val = max_val = min_val1 = max_val1 = 0.;

_f_param2 = 0.;

break;

default:

min_val = max_val = min_val1 = max_val1 = 0.;

_f_param1 = 1.;

_f_param2 = 0.;

}

f_param1 = _f_param1;

f_param2 = _f_param2;

}

void init_weights()

{

int i, j, k, l_count = layer_count();

for( i = 1; i < l_count; i++ )

{

int n1 = layer_sizes[i-1];

int n2 = layer_sizes[i];

double val = 0, G = n2 > 2 ? 0.7*pow((double)n1,1./(n2-1)) : 1.;

double* w = weights[i].ptr<double>();

// initialize weights using Nguyen-Widrow algorithm

for( j = 0; j < n2; j++ )

{

double s = 0;

for( k = 0; k <= n1; k++ )

{

val = rng.uniform(0., 1.)*2-1.;

w[k*n2 + j] = val;

s += fabs(val);

}

if( i < l_count - 1 )

{

s = 1./(s - fabs(val));

for( k = 0; k <= n1; k++ )

w[k*n2 + j] *= s;

w[n1*n2 + j] *= G*(-1+j*2./n2);

}

}

}

}

Mat getLayerSizes() const

{

return Mat_<int>(layer_sizes, true);

}

void setLayerSizes( InputArray _layer_sizes )

{

clear();

_layer_sizes.copyTo(layer_sizes);

int l_count = layer_count();

weights.resize(l_count + 2);

max_lsize = 0;

if( l_count > 0 )

{

for( int i = 0; i < l_count; i++ )

{

int n = layer_sizes[i];

if( n < 1 + (0 < i && i < l_count-1))

CV_Error( CV_StsOutOfRange,

"there should be at least one input and one output "

"and every hidden layer must have more than 1 neuron" );

max_lsize = std::max( max_lsize, n );

if( i > 0 )

weights[i].create(layer_sizes[i-1]+1, n, CV_64F);

}

int ninputs = layer_sizes.front();

int noutputs = layer_sizes.back();

weights[0].create(1, ninputs*2, CV_64F);

weights[l_count].create(1, noutputs*2, CV_64F);

weights[l_count+1].create(1, noutputs*2, CV_64F);

}

}

float predict( InputArray _inputs, OutputArray _outputs, int ) const

{

if( !trained )

CV_Error( CV_StsError, "The network has not been trained or loaded" );

Mat inputs = _inputs.getMat();

int type = inputs.type(), l_count = layer_count();

int n = inputs.rows, dn0 = n;

CV_Assert( (type == CV_32F || type == CV_64F) && inputs.cols == layer_sizes[0] );

int noutputs = layer_sizes[l_count-1];

Mat outputs;

int min_buf_sz = 2*max_lsize;

int buf_sz = n*min_buf_sz;

if( buf_sz > max_buf_sz )

{

dn0 = max_buf_sz/min_buf_sz;

dn0 = std::max( dn0, 1 );

buf_sz = dn0*min_buf_sz;

}

cv::AutoBuffer<double> _buf(buf_sz+noutputs);

double* buf = _buf;

if( !_outputs.needed() )

{

CV_Assert( n == 1 );

outputs = Mat(n, noutputs, type, buf + buf_sz);

}

else

{

_outputs.create(n, noutputs, type);

outputs = _outputs.getMat();

}

int dn = 0;

for( int i = 0; i < n; i += dn )

{

dn = std::min( dn0, n - i );

Mat layer_in = inputs.rowRange(i, i + dn);

Mat layer_out( dn, layer_in.cols, CV_64F, buf);

scale_input( layer_in, layer_out );

layer_in = layer_out;

for( int j = 1; j < l_count; j++ )

{

double* data = buf + ((j&1) ? max_lsize*dn0 : 0);

int cols = layer_sizes[j];

layer_out = Mat(dn, cols, CV_64F, data);

Mat w = weights[j].rowRange(0, layer_in.cols);

gemm(layer_in, w, 1, noArray(), 0, layer_out);

calc_activ_func( layer_out, weights[j] );

layer_in = layer_out;

}

layer_out = outputs.rowRange(i, i + dn);

scale_output( layer_in, layer_out );

}

if( n == 1 )

{

int maxIdx[] = {0, 0};

minMaxIdx(outputs, 0, 0, 0, maxIdx);

return (float)(maxIdx[0] + maxIdx[1]);

}

return 0.f;

}

void scale_input( const Mat& _src, Mat& _dst ) const

{

int cols = _src.cols;

const double* w = weights[0].ptr<double>();

if( _src.type() == CV_32F )

{

for( int i = 0; i < _src.rows; i++ )

{

const float* src = _src.ptr<float>(i);

double* dst = _dst.ptr<double>(i);

for( int j = 0; j < cols; j++ )

dst[j] = src[j]*w[j*2] + w[j*2+1];

}

}

else

{

for( int i = 0; i < _src.rows; i++ )

{

const double* src = _src.ptr<double>(i);

double* dst = _dst.ptr<double>(i);

for( int j = 0; j < cols; j++ )

dst[j] = src[j]*w[j*2] + w[j*2+1];

}

}

}

void scale_output( const Mat& _src, Mat& _dst ) const

{

int cols = _src.cols;

const double* w = weights[layer_count()].ptr<double>();

if( _dst.type() == CV_32F )

{

for( int i = 0; i < _src.rows; i++ )

{

const double* src = _src.ptr<double>(i);

float* dst = _dst.ptr<float>(i);

for( int j = 0; j < cols; j++ )

dst[j] = (float)(src[j]*w[j*2] + w[j*2+1]);

}

}

else

{

for( int i = 0; i < _src.rows; i++ )

{

const double* src = _src.ptr<double>(i);

double* dst = _dst.ptr<double>(i);

for( int j = 0; j < cols; j++ )

dst[j] = src[j]*w[j*2] + w[j*2+1];

}

}

}

void calc_activ_func(Mat& sums, const Mat& w) const

{

const double* bias = w.ptr<double>(w.rows - 1);

int i, j, n = sums.rows, cols = sums.cols;

double scale = 0, scale2 = f_param2;

switch (activ_func)

{

case IDENTITY:

scale = 1.;

break;

case SIGMOID_SYM:

scale = -f_param1;

break;

case GAUSSIAN:

scale = -f_param1*f_param1;

break;

case RELU:

scale = 1;

break;

case LEAKYRELU:

scale = 1;

break;

default:

;

}

CV_Assert(sums.isContinuous());

if (activ_func != GAUSSIAN)

{

for (i = 0; i < n; i++)

{

double* data = sums.ptr<double>(i);

for (j = 0; j < cols; j++)

{

data[j] = (data[j] + bias[j])*scale;

if (activ_func == RELU)

if (data[j] < 0)

data[j] = 0;

if (activ_func == LEAKYRELU)

if (data[j] < 0)

data[j] *= f_param1;

}

}

if (activ_func == IDENTITY || activ_func == RELU || activ_func == LEAKYRELU)

return;

}

else

{

for (i = 0; i < n; i++)

{

double* data = sums.ptr<double>(i);

for (j = 0; j < cols; j++)

{

double t = data[j] + bias[j];

data[j] = t*t*scale;

}

}

}

exp(sums, sums);

if (sums.isContinuous())

{

cols *= n;

n = 1;

}

switch (activ_func)

{

case SIGMOID_SYM:

for (i = 0; i < n; i++)

{

double* data = sums.ptr<double>(i);

for (j = 0; j < cols; j++)

{

if (!cvIsInf(data[j]))

{

double t = scale2*(1. - data[j]) / (1. + data[j]);

data[j] = t;

}

else

{

data[j] = -scale2;

}

}

}

break;

case GAUSSIAN:

for (i = 0; i < n; i++)

{

double* data = sums.ptr<double>(i);

for (j = 0; j < cols; j++)

data[j] = scale2*data[j];

}

break;

default:

;

}

}

void calc_activ_func_deriv(Mat& _xf, Mat& _df, const Mat& w) const

{

const double* bias = w.ptr<double>(w.rows - 1);

int i, j, n = _xf.rows, cols = _xf.cols;

if (activ_func == IDENTITY)

{

for (i = 0; i < n; i++)

{

double* xf = _xf.ptr<double>(i);

double* df = _df.ptr<double>(i);

for (j = 0; j < cols; j++)

{

xf[j] += bias[j];

df[j] = 1;

}

}

}

else if (activ_func == RELU)

{

for (i = 0; i < n; i++)

{

double* xf = _xf.ptr<double>(i);

double* df = _df.ptr<double>(i);

for (j = 0; j < cols; j++)

{

xf[j] += bias[j];

if (xf[j] < 0)

{

xf[j] = 0;

df[j] = 0;

}

else

df[j] = 1;

}

}

}

else if (activ_func == LEAKYRELU)

{

for (i = 0; i < n; i++)

{

double* xf = _xf.ptr<double>(i);

double* df = _df.ptr<double>(i);

for (j = 0; j < cols; j++)

{

xf[j] += bias[j];

if (xf[j] < 0)

{

xf[j] = f_param1*xf[j];

df[j] = f_param1;

}

else

df[j] = 1;

}

}

}

else if (activ_func == GAUSSIAN)

{

double scale = -f_param1*f_param1;

double scale2 = scale*f_param2;

for (i = 0; i < n; i++)

{

double* xf = _xf.ptr<double>(i);

double* df = _df.ptr<double>(i);

for (j = 0; j < cols; j++)

{

double t = xf[j] + bias[j];

df[j] = t * 2 * scale2;

xf[j] = t*t*scale;

}

}

exp(_xf, _xf);

for (i = 0; i < n; i++)

{

double* xf = _xf.ptr<double>(i);

double* df = _df.ptr<double>(i);

for (j = 0; j < cols; j++)

df[j] *= xf[j];

}

}

else

{

double scale = f_param1;

double scale2 = f_param2;

for (i = 0; i < n; i++)

{

double* xf = _xf.ptr<double>(i);

double* df = _df.ptr<double>(i);

for (j = 0; j < cols; j++)

{

xf[j] = (xf[j] + bias[j])*scale;

df[j] = -fabs(xf[j]);

}

}

exp(_df, _df);

// ((1+exp(-ax))^-1)'=a*((1+exp(-ax))^-2)*exp(-ax);

// ((1-exp(-ax))/(1+exp(-ax)))'=(a*exp(-ax)*(1+exp(-ax)) + a*exp(-ax)*(1-exp(-ax)))/(1+exp(-ax))^2=

// 2*a*exp(-ax)/(1+exp(-ax))^2

scale *= 2 * f_param2;

for (i = 0; i < n; i++)

{

double* xf = _xf.ptr<double>(i);

double* df = _df.ptr<double>(i);

for (j = 0; j < cols; j++)

{

int s0 = xf[j] > 0 ? 1 : -1;

double t0 = 1. / (1. + df[j]);

double t1 = scale*df[j] * t0*t0;

t0 *= scale2*(1. - df[j])*s0;

df[j] = t1;

xf[j] = t0;

}

}

}

}

void calc_input_scale( const Mat& inputs, int flags )

{

bool reset_weights = (flags & UPDATE_WEIGHTS) == 0;

bool no_scale = (flags & NO_INPUT_SCALE) != 0;

double* scale = weights[0].ptr<double>();

int count = inputs.rows;

if( reset_weights )

{

int i, j, vcount = layer_sizes[0];

int type = inputs.type();

double a = no_scale ? 1. : 0.;

for( j = 0; j < vcount; j++ )

scale[2*j] = a, scale[j*2+1] = 0.;

if( no_scale )

return;

for( i = 0; i < count; i++ )

{

const uchar* p = inputs.ptr(i);

const float* f = (const float*)p;

const double* d = (const double*)p;

for( j = 0; j < vcount; j++ )

{

double t = type == CV_32F ? (double)f[j] : d[j];

scale[j*2] += t;

scale[j*2+1] += t*t;

}

}

for( j = 0; j < vcount; j++ )

{

double s = scale[j*2], s2 = scale[j*2+1];

double m = s/count, sigma2 = s2/count - m*m;

scale[j*2] = sigma2 < DBL_EPSILON ? 1 : 1./sqrt(sigma2);

scale[j*2+1] = -m*scale[j*2];

}

}

}

void calc_output_scale( const Mat& outputs, int flags )

{

int i, j, vcount = layer_sizes.back();

int type = outputs.type();

double m = min_val, M = max_val, m1 = min_val1, M1 = max_val1;

bool reset_weights = (flags & UPDATE_WEIGHTS) == 0;

bool no_scale = (flags & NO_OUTPUT_SCALE) != 0;

int l_count = layer_count();

double* scale = weights[l_count].ptr<double>();

double* inv_scale = weights[l_count+1].ptr<double>();

int count = outputs.rows;

if( reset_weights )

{

double a0 = no_scale ? 1 : DBL_MAX, b0 = no_scale ? 0 : -DBL_MAX;

for( j = 0; j < vcount; j++ )

{

scale[2*j] = inv_scale[2*j] = a0;

scale[j*2+1] = inv_scale[2*j+1] = b0;

}

if( no_scale )

return;

}

for( i = 0; i < count; i++ )

{

const uchar* p = outputs.ptr(i);

const float* f = (const float*)p;

const double* d = (const double*)p;

for( j = 0; j < vcount; j++ )

{

double t = type == CV_32F ? (double)f[j] : d[j];

if( reset_weights )

{

double mj = scale[j*2], Mj = scale[j*2+1];

if( mj > t ) mj = t;

if( Mj < t ) Mj = t;

scale[j*2] = mj;

scale[j*2+1] = Mj;

}

else if( !no_scale )

{

t = t*inv_scale[j*2] + inv_scale[2*j+1];

if( t < m1 || t > M1 )

CV_Error( CV_StsOutOfRange,

"Some of new output training vector components run exceed the original range too much" );

}

}

}

if( reset_weights )

for( j = 0; j < vcount; j++ )

{

// map mj..Mj to m..M

double mj = scale[j*2], Mj = scale[j*2+1];

double a, b;

double delta = Mj - mj;

if( delta < DBL_EPSILON )

a = 1, b = (M + m - Mj - mj)*0.5;

else

a = (M - m)/delta, b = m - mj*a;

inv_scale[j*2] = a; inv_scale[j*2+1] = b;

a = 1./a; b = -b*a;

scale[j*2] = a; scale[j*2+1] = b;

}

}

void prepare_to_train( const Mat& inputs, const Mat& outputs,

Mat& sample_weights, int flags )

{

if( layer_sizes.empty() )

CV_Error( CV_StsError,

"The network has not been created. Use method create or the appropriate constructor" );

if( (inputs.type() != CV_32F && inputs.type() != CV_64F) ||

inputs.cols != layer_sizes[0] )

CV_Error( CV_StsBadArg,

"input training data should be a floating-point matrix with "

"the number of rows equal to the number of training samples and "

"the number of columns equal to the size of 0-th (input) layer" );

if( (outputs.type() != CV_32F && outputs.type() != CV_64F) ||

outputs.cols != layer_sizes.back() )

CV_Error( CV_StsBadArg,

"output training data should be a floating-point matrix with "

"the number of rows equal to the number of training samples and "

"the number of columns equal to the size of last (output) layer" );

if( inputs.rows != outputs.rows )

CV_Error( CV_StsUnmatchedSizes, "The numbers of input and output samples do not match" );

Mat temp;

double s = sum(sample_weights)[0];

sample_weights.convertTo(temp, CV_64F, 1./s);

sample_weights = temp;

calc_input_scale( inputs, flags );

calc_output_scale( outputs, flags );

}

bool train( const Ptr<TrainData>& trainData, int flags )

{

const int MAX_ITER = 1000;

const double DEFAULT_EPSILON = FLT_EPSILON;

// initialize training data

Mat inputs = trainData->getTrainSamples();

Mat outputs = trainData->getTrainResponses();

Mat sw = trainData->getTrainSampleWeights();

prepare_to_train( inputs, outputs, sw, flags );

// ... and link weights

if( !(flags & UPDATE_WEIGHTS) )

init_weights();

TermCriteria termcrit;

termcrit.type = TermCriteria::COUNT + TermCriteria::EPS;

termcrit.maxCount = std::max((params.termCrit.type & CV_TERMCRIT_ITER ? params.termCrit.maxCount : MAX_ITER), 1);

termcrit.epsilon = std::max((params.termCrit.type & CV_TERMCRIT_EPS ? params.termCrit.epsilon : DEFAULT_EPSILON), DBL_EPSILON);

int iter = 0;

switch(params.trainMethod){

case ANN_MLP::BACKPROP:

iter = train_backprop(inputs, outputs, sw, termcrit);

break;

case ANN_MLP::RPROP:

iter = train_rprop(inputs, outputs, sw, termcrit);

break;

case ANN_MLP::ANNEAL:

iter = train_anneal(trainData);

break;

}

trained = iter > 0;

return trained;

}

int train_anneal(const Ptr<TrainData>& trainData)

{

SimulatedAnnealingANN_MLP s(*this, trainData);

trained = true; // Enable call to CalcError

int iter = simulatedAnnealingSolver(s, params.initialT, params.finalT, params.coolingRatio, params.itePerStep, NULL, params.rEnergy);

trained =false;

return iter + 1; // ensure that 'train()' call is always successful

}

int train_backprop( const Mat& inputs, const Mat& outputs, const Mat& _sw, TermCriteria termCrit )

{

int i, j, k;

double prev_E = DBL_MAX*0.5, E = 0;

int itype = inputs.type(), otype = outputs.type();

int count = inputs.rows;

int iter = -1, max_iter = termCrit.maxCount*count;

double epsilon = termCrit.epsilon*count;

int l_count = layer_count();

int ivcount = layer_sizes[0];

int ovcount = layer_sizes.back();

// allocate buffers

vector<vector<double> > x(l_count);

vector<vector<double> > df(l_count);

vector<Mat> dw(l_count);

for( i = 0; i < l_count; i++ )

{

int n = layer_sizes[i];

x[i].resize(n+1);

df[i].resize(n);

dw[i] = Mat::zeros(weights[i].size(), CV_64F);

}

Mat _idx_m(1, count, CV_32S);

int* _idx = _idx_m.ptr<int>();

for( i = 0; i < count; i++ )

_idx[i] = i;

AutoBuffer<double> _buf(max_lsize*2);

double* buf[] = { _buf, (double*)_buf + max_lsize };

const double* sw = _sw.empty() ? 0 : _sw.ptr<double>();

// run back-propagation loop

/*