const float** images,

const CvMat* responses,

const CvMat* etalons,

int grad_estim_type,

int max_iter,

int start_iter )

{

CvMat** X = 0;

CvMat** dE_dX = 0;

const int n_layers = network->n_layers;

int k;

CV_FUNCNAME("icvTrainCNNetwork");

__BEGIN__;

CvCNNLayer* first_layer = network->layers;

const int img_height = first_layer->input_height;

const int img_width = first_layer->input_width;

const int img_size = img_width*img_height;

const int n_images = responses->cols;

CvMat image = cvMat( 1, img_size, CV_32FC1 );

CvCNNLayer* layer;

int n;

CvRNG rng = cvRNG(-1);

CV_CALL(X = (CvMat**)cvAlloc( (n_layers+1)*sizeof(CvMat*) ));

CV_CALL(dE_dX = (CvMat**)cvAlloc( (n_layers+1)*sizeof(CvMat*) ));

memset( X, 0, (n_layers+1)*sizeof(CvMat*) );

memset( dE_dX, 0, (n_layers+1)*sizeof(CvMat*) );

CV_CALL(X[0] = cvCreateMat( img_height*img_width,1,CV_32FC1 ));

CV_CALL(dE_dX[0] = cvCreateMat( 1, X[0]->rows, CV_32FC1 ));

for( k = 0, layer = first_layer; k < n_layers; k++, layer = layer->next_layer )

{

CV_CALL(X[k+1] = cvCreateMat( layer->n_output_planes*layer->output_height*

layer->output_width, 1, CV_32FC1 ));

CV_CALL(dE_dX[k+1] = cvCreateMat( 1, X[k+1]->rows, CV_32FC1 ));

}

for( n = 1; n <= max_iter; n++ )

{

float loss, max_loss = 0;

int i;

int worst_img_idx = -1;

int* right_etal_idx = responses->data.i;

CvMat etalon;

// Find the worst image (which produces the greatest loss) or use the random image

if( grad_estim_type == CV_CNN_GRAD_ESTIM_BY_WORST_IMG )

{

for( i = 0; i < n_images; i++, right_etal_idx++ )

{

image.data.fl = (float*)images[i];

cvTranspose( &image, X[0] );

for( k = 0, layer = first_layer; k < n_layers; k++, layer = layer->next_layer )

CV_CALL(layer->forward( layer, X[k], X[k+1] ));

cvTranspose( X[n_layers], dE_dX[n_layers] );

cvGetRow( etalons, &etalon, *right_etal_idx );

loss = (float)cvNorm( dE_dX[n_layers], &etalon );

if( loss > max_loss )

{

max_loss = loss;

worst_img_idx = i;

}

}

}

else

worst_img_idx = cvRandInt(&rng) % n_images;

// Train network on the worst image

// 1) Compute the network output on the <image>

image.data.fl = (float*)images[worst_img_idx];

CV_CALL(cvTranspose( &image, X[0] ));

for( k = 0, layer = first_layer; k < n_layers - 1; k++, layer = layer->next_layer )

CV_CALL(layer->forward( layer, X[k], X[k+1] ));

CV_CALL(layer->forward( layer, X[k], X[k+1] ));

// 2) Compute the gradient

cvTranspose( X[n_layers], dE_dX[n_layers] );

cvGetRow( etalons, &etalon, responses->data.i[worst_img_idx] );

cvSub( dE_dX[n_layers], &etalon, dE_dX[n_layers] );

// 3) Update weights by the gradient descent

for( k = n_layers; k > 0; k--, layer = layer->prev_layer )

CV_CALL(layer->backward( layer, n + start_iter, X[k-1], dE_dX[k], dE_dX[k-1] ));

}

__END__;

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

{

cvReleaseMat( &X[k] );

cvReleaseMat( &dE_dX[k] );

}

cvFree( &X );

cvFree( &dE_dX );

const CvMat* _image,

CvMat* probs )

{

CvMat** X = 0;

float* img_data = 0;

int n_layers = 0;

int best_etal_idx = -1;

int k;

CV_FUNCNAME("icvCNNModelPredict");

__BEGIN__;

CvCNNStatModel* cnn_model = (CvCNNStatModel*)model;

CvCNNLayer* first_layer, *layer = 0;

int img_height, img_width, img_size;

int nclasses, i;

float loss, min_loss = FLT_MAX;

float* probs_data;

CvMat etalon, image;

if( !CV_IS_CNN(model) )

CV_ERROR( CV_StsBadArg, "Invalid model" );

nclasses = cnn_model->cls_labels->cols;

n_layers = cnn_model->network->n_layers;

first_layer = cnn_model->network->layers;

img_height = first_layer->input_height;

img_width = first_layer->input_width;

img_size = img_height*img_width;

cvPreparePredictData( _image, img_size, 0, nclasses, probs, &img_data );

CV_CALL(X = (CvMat**)cvAlloc( (n_layers+1)*sizeof(CvMat*) ));

memset( X, 0, (n_layers+1)*sizeof(CvMat*) );

CV_CALL(X[0] = cvCreateMat( img_size,1,CV_32FC1 ));

for( k = 0, layer = first_layer; k < n_layers; k++, layer = layer->next_layer )

{

CV_CALL(X[k+1] = cvCreateMat( layer->n_output_planes*layer->output_height*

layer->output_width, 1, CV_32FC1 ));

}

image = cvMat( 1, img_size, CV_32FC1, img_data );

cvTranspose( &image, X[0] );

for( k = 0, layer = first_layer; k < n_layers; k++, layer = layer->next_layer )

CV_CALL(layer->forward( layer, X[k], X[k+1] ));

probs_data = probs ? probs->data.fl : 0;

etalon = cvMat( cnn_model->etalons->cols, 1, CV_32FC1, cnn_model->etalons->data.fl );

for( i = 0; i < nclasses; i++, etalon.data.fl += cnn_model->etalons->cols )

{

loss = (float)cvNorm( X[n_layers], &etalon );

if( loss < min_loss )

{

min_loss = loss;

best_etal_idx = i;

}

if( probs )

*probs_data++ = -loss;

}

if( probs )

{

cvExp( probs, probs );

CvScalar sum = cvSum( probs );

cvConvertScale( probs, probs, 1./sum.val[0] );

}

__END__;

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

cvReleaseMat( &X[k] );

cvFree( &X );

if( img_data != _image->data.fl )

cvFree( &img_data );

return ((float) ((CvCNNStatModel*)model)->cls_labels->data.i[best_etal_idx]);

CvStatModel* _cnn_model, const CvMat* _train_data, int tflag,

const CvMat* _responses, const CvStatModelParams* _params,

const CvMat*, const CvMat* _sample_idx,

const CvMat*, const CvMat* )

{

const float** out_train_data = 0;

CvMat* responses = 0;

CvMat* cls_labels = 0;

CV_FUNCNAME("icvCNNModelUpdate");

__BEGIN__;

int n_images, img_size, i;

CvCNNStatModelParams* params = (CvCNNStatModelParams*)_params;

CvCNNStatModel* cnn_model = (CvCNNStatModel*)_cnn_model;

if( !CV_IS_CNN(cnn_model) )

CV_ERROR( CV_StsBadArg, "Invalid model" );

CV_CALL(cvPrepareTrainData( "cvTrainCNNClassifier",

_train_data, tflag, _responses, CV_VAR_CATEGORICAL,

0, _sample_idx, false, &out_train_data,

&n_images, &img_size, &img_size, &responses,

&cls_labels, 0, 0 ));

ICV_CHECK_CNN_MODEL_PARAMS(params);

// Number of classes must be the same as when classifiers was created

if( !CV_ARE_SIZES_EQ(cls_labels, cnn_model->cls_labels) )

CV_ERROR( CV_StsBadArg, "Number of classes must be left unchanged" );

for( i = 0; i < cls_labels->cols; i++ )

{

if( cls_labels->data.i[i] != cnn_model->cls_labels->data.i[i] )

CV_ERROR( CV_StsBadArg, "Number of classes must be left unchanged" );

}

CV_CALL( icvTrainCNNetwork( cnn_model->network, out_train_data, responses,

cnn_model->etalons, params->grad_estim_type, params->max_iter,

params->start_iter ));

__END__;

cvFree( &out_train_data );

cvReleaseMat( &responses );

{

CV_FUNCNAME("icvCNNModelRelease");

__BEGIN__;

CvCNNStatModel* cnn;

if( !cnn_model )

CV_ERROR( CV_StsNullPtr, "Null double pointer" );

cnn = *(CvCNNStatModel**)cnn_model;

cvReleaseMat( &cnn->cls_labels );

cvReleaseMat( &cnn->etalons );

cnn->network->release( &cnn->network );

cvFree( &cnn );

__END__;

{

CV_FUNCNAME( "icvCNNetworkAddLayer" );

__BEGIN__;

CvCNNLayer* prev_layer;

if( network == NULL )

CV_ERROR( CV_StsNullPtr, "Null <network> pointer" );

prev_layer = network->layers;

while( prev_layer->next_layer )

prev_layer = prev_layer->next_layer;

if( ICV_IS_CNN_FULLCONNECT_LAYER(layer) )

{

if( layer->n_input_planes != prev_layer->output_width*prev_layer->output_height*

prev_layer->n_output_planes )

CV_ERROR( CV_StsBadArg, "Unmatched size of the new layer" );

if( layer->input_height != 1 || layer->output_height != 1 ||

layer->input_width != 1 || layer->output_width != 1 )

CV_ERROR( CV_StsBadArg, "Invalid size of the new layer" );

}

else if( ICV_IS_CNN_CONVOLUTION_LAYER(layer) || ICV_IS_CNN_SUBSAMPLING_LAYER(layer) )

{

if( prev_layer->n_output_planes != layer->n_input_planes ||

prev_layer->output_height != layer->input_height ||

prev_layer->output_width != layer->input_width )

CV_ERROR( CV_StsBadArg, "Unmatched size of the new layer" );

}

else

CV_ERROR( CV_StsBadArg, "Invalid layer" );

layer->prev_layer = prev_layer;

prev_layer->next_layer = layer;

network->n_layers++;

__END__;

{

CV_FUNCNAME( "icvReleaseCNNetwork" );

__BEGIN__;

CvCNNetwork* network = 0;

CvCNNLayer* layer = 0, *next_layer = 0;

int k;

if( network_pptr == NULL )

CV_ERROR( CV_StsBadArg, "Null double pointer" );

if( *network_pptr == NULL )

return;

network = *network_pptr;

layer = network->layers;

if( layer == NULL )

CV_ERROR( CV_StsBadArg, "CNN is empty (does not contain any layer)" );

// k is the number of the layer to be deleted

for( k = 0; k < network->n_layers && layer; k++ )

{

next_layer = layer->next_layer;

layer->release( &layer );

layer = next_layer;

}

if( k != network->n_layers || layer)

CV_ERROR( CV_StsBadArg, "Invalid network" );

cvFree( &network );

__END__;

const CvMat* X,

CvMat* Y )

{

CV_FUNCNAME("icvCNNConvolutionForward");

if( !ICV_IS_CNN_CONVOLUTION_LAYER(_layer) )

CV_ERROR( CV_StsBadArg, "Invalid layer" );

{__BEGIN__;

const CvCNNConvolutionLayer* layer = (CvCNNConvolutionLayer*) _layer;

const int K = layer->K;

const int n_weights_for_Yplane = K*K + 1;

const int nXplanes = layer->n_input_planes;

const int Xheight = layer->input_height;

const int Xwidth = layer->input_width ;

const int Xsize = Xwidth*Xheight;

const int nYplanes = layer->n_output_planes;

const int Yheight = layer->output_height;

const int Ywidth = layer->output_width;

const int Ysize = Ywidth*Yheight;

int xx, yy, ni, no, kx, ky;

float *Yplane = 0, *Xplane = 0, *w = 0;

uchar* connect_mask_data = 0;

CV_ASSERT( X->rows == nXplanes*Xsize && X->cols == 1 );

CV_ASSERT( Y->rows == nYplanes*Ysize && Y->cols == 1 );

cvSetZero( Y );

Yplane = Y->data.fl;

connect_mask_data = layer->connect_mask->data.ptr;

w = layer->weights->data.fl;

for( no = 0; no < nYplanes; no++, Yplane += Ysize, w += n_weights_for_Yplane )

{

Xplane = X->data.fl;

for( ni = 0; ni < nXplanes; ni++, Xplane += Xsize, connect_mask_data++ )

{

if( *connect_mask_data )

{

float* Yelem = Yplane;

// Xheight-K+1 == Yheight && Xwidth-K+1 == Ywidth

for( yy = 0; yy < Xheight-K+1; yy++ )

{

for( xx = 0; xx < Xwidth-K+1; xx++, Yelem++ )

{

float* templ = Xplane+yy*Xwidth+xx;

float WX = 0;

for( ky = 0; ky < K; ky++, templ += Xwidth-K )

{

for( kx = 0; kx < K; kx++, templ++ )

{

WX += *templ*w[ky*K+kx];

}

}

*Yelem += WX + w[K*K];

}

}

}

}

}

}__END__;

const CvMat* X,

CvMat* Y )

{

CV_FUNCNAME("icvCNNSubSamplingForward");

if( !ICV_IS_CNN_SUBSAMPLING_LAYER(_layer) )

CV_ERROR( CV_StsBadArg, "Invalid layer" );

{__BEGIN__;

const CvCNNSubSamplingLayer* layer = (CvCNNSubSamplingLayer*) _layer;

const int sub_sampl_scale = layer->sub_samp_scale;

const int nplanes = layer->n_input_planes;

const int Xheight = layer->input_height;

const int Xwidth = layer->input_width ;

const int Xsize = Xwidth*Xheight;

const int Yheight = layer->output_height;

const int Ywidth = layer->output_width;

const int Ysize = Ywidth*Yheight;

int xx, yy, ni, kx, ky;

float* sumX_data = 0, *w = 0;

CvMat sumX_sub_col, exp2ssumWX_sub_col;

CV_ASSERT(X->rows == nplanes*Xsize && X->cols == 1);

CV_ASSERT(layer->exp2ssumWX->cols == 1 && layer->exp2ssumWX->rows == nplanes*Ysize);

// update inner variable layer->exp2ssumWX, which will be used in back-progation

cvZero( layer->sumX );

cvZero( layer->exp2ssumWX );

for( ky = 0; ky < sub_sampl_scale; ky++ )

for( kx = 0; kx < sub_sampl_scale; kx++ )

{

float* Xplane = X->data.fl;

sumX_data = layer->sumX->data.fl;

for( ni = 0; ni < nplanes; ni++, Xplane += Xsize )

{

for( yy = 0; yy < Yheight; yy++ )

for( xx = 0; xx < Ywidth; xx++, sumX_data++ )

*sumX_data += Xplane[((yy+ky)*Xwidth+(xx+kx))];

}

}

w = layer->weights->data.fl;

cvGetRows( layer->sumX, &sumX_sub_col, 0, Ysize );

cvGetRows( layer->exp2ssumWX, &exp2ssumWX_sub_col, 0, Ysize );

for( ni = 0; ni < nplanes; ni++, w += 2 )

{

CV_CALL(cvConvertScale( &sumX_sub_col, &exp2ssumWX_sub_col, w[0], w[1] ));

sumX_sub_col.data.fl += Ysize;

exp2ssumWX_sub_col.data.fl += Ysize;

}

CV_CALL(cvScale( layer->exp2ssumWX, layer->exp2ssumWX, 2.0*layer->s ));

CV_CALL(cvExp( layer->exp2ssumWX, layer->exp2ssumWX ));

CV_CALL(cvMinS( layer->exp2ssumWX, FLT_MAX, layer->exp2ssumWX ));

//#ifdef _DEBUG

{

float* exp2ssumWX_data = layer->exp2ssumWX->data.fl;

for( ni = 0; ni < layer->exp2ssumWX->rows; ni++, exp2ssumWX_data++ )

{

if( *exp2ssumWX_data == FLT_MAX )

cvSetErrStatus( 1 );

}

}

//#endif

// compute the output variable Y == ( a - 2a/(layer->exp2ssumWX + 1))

CV_CALL(cvAddS( layer->exp2ssumWX, cvRealScalar(1), Y ));

CV_CALL(cvDiv( 0, Y, Y, -2.0*layer->a ));

CV_CALL(cvAddS( Y, cvRealScalar(layer->a), Y ));

}__END__;

{

CV_FUNCNAME("icvCNNFullConnectForward");

if( !ICV_IS_CNN_FULLCONNECT_LAYER(_layer) )

CV_ERROR( CV_StsBadArg, "Invalid layer" );

{__BEGIN__;

const CvCNNFullConnectLayer* layer = (CvCNNFullConnectLayer*)_layer;

CvMat* weights = layer->weights;

CvMat sub_weights, bias;

CV_ASSERT(X->cols == 1 && X->rows == layer->n_input_planes);

CV_ASSERT(Y->cols == 1 && Y->rows == layer->n_output_planes);

CV_CALL(cvGetSubRect( weights, &sub_weights,

cvRect(0, 0, weights->cols-1, weights->rows )));

CV_CALL(cvGetCol( weights, &bias, weights->cols-1));

// update inner variable layer->exp2ssumWX, which will be used in Back-Propagation

CV_CALL(cvGEMM( &sub_weights, X, 2*layer->s, &bias, 2*layer->s, layer->exp2ssumWX ));

CV_CALL(cvExp( layer->exp2ssumWX, layer->exp2ssumWX ));

CV_CALL(cvMinS( layer->exp2ssumWX, FLT_MAX, layer->exp2ssumWX ));

//#ifdef _DEBUG

{

float* exp2ssumWX_data = layer->exp2ssumWX->data.fl;

int i;

for( i = 0; i < layer->exp2ssumWX->rows; i++, exp2ssumWX_data++ )

{

if( *exp2ssumWX_data == FLT_MAX )

cvSetErrStatus( 1 );

}

}

//#endif

// compute the output variable Y == ( a - 2a/(layer->exp2ssumWX + 1))