1 /*M/////////////////////////////////////////////////////////////////////////////////////// 2 // 3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 // 5 // By downloading, copying, installing or using the software you agree to this license. 6 // If you do not agree to this license, do not download, install, 7 // copy or use the software. 8 // 9 // 10 // Intel License Agreement 11 // 12 // Copyright (C) 2000, Intel Corporation, all rights reserved. 13 // Third party copyrights are property of their respective owners. 14 // 15 // Redistribution and use in source and binary forms, with or without modification, 16 // are permitted provided that the following conditions are met: 17 // 18 // * Redistribution's of source code must retain the above copyright notice, 19 // this list of conditions and the following disclaimer. 20 // 21 // * Redistribution's in binary form must reproduce the above copyright notice, 22 // this list of conditions and the following disclaimer in the documentation 23 // and/or other materials provided with the distribution. 24 // 25 // * The name of Intel Corporation may not be used to endorse or promote products 26 // derived from this software without specific prior written permission. 27 // 28 // This software is provided by the copyright holders and contributors "as is" and 29 // any express or implied warranties, including, but not limited to, the implied 30 // warranties of merchantability and fitness for a particular purpose are disclaimed. 31 // In no event shall the Intel Corporation or contributors be liable for any direct, 32 // indirect, incidental, special, exemplary, or consequential damages 33 // (including, but not limited to, procurement of substitute goods or services; 34 // loss of use, data, or profits; or business interruption) however caused 35 // and on any theory of liability, whether in contract, strict liability, 36 // or tort (including negligence or otherwise) arising in any way out of 37 // the use of this software, even if advised of the possibility of such damage. 38 // 39 //M*/ 40 41 #include "_ml.h" 42 43 #if 0 44 /****************************************************************************************\ 45 * Auxilary functions declarations * 46 \****************************************************************************************/ 47 /*---------------------- functions for the CNN classifier ------------------------------*/ 48 static float icvCNNModelPredict( 49 const CvStatModel* cnn_model, 50 const CvMat* image, 51 CvMat* probs CV_DEFAULT(0) ); 52 53 static void icvCNNModelUpdate( 54 CvStatModel* cnn_model, const CvMat* images, int tflag, 55 const CvMat* responses, const CvStatModelParams* params, 56 const CvMat* CV_DEFAULT(0), const CvMat* sample_idx CV_DEFAULT(0), 57 const CvMat* CV_DEFAULT(0), const CvMat* CV_DEFAULT(0)); 58 59 static void icvCNNModelRelease( CvStatModel** cnn_model ); 60 61 static void icvTrainCNNetwork( CvCNNetwork* network, 62 const float** images, 63 const CvMat* responses, 64 const CvMat* etalons, 65 int grad_estim_type, 66 int max_iter, 67 int start_iter ); 68 69 /*------------------------- functions for the CNN network ------------------------------*/ 70 static void icvCNNetworkAddLayer( CvCNNetwork* network, CvCNNLayer* layer ); 71 static void icvCNNetworkRelease( CvCNNetwork** network ); 72 73 /* In all layer functions we denote input by X and output by Y, where 74 X and Y are column-vectors, so that 75 length(X)==<n_input_planes>*<input_height>*<input_width>, 76 length(Y)==<n_output_planes>*<output_height>*<output_width>. 77 */ 78 /*------------------------ functions for convolutional layer ---------------------------*/ 79 static void icvCNNConvolutionRelease( CvCNNLayer** p_layer ); 80 81 static void icvCNNConvolutionForward( CvCNNLayer* layer, const CvMat* X, CvMat* Y ); 82 83 static void icvCNNConvolutionBackward( CvCNNLayer* layer, int t, 84 const CvMat* X, const CvMat* dE_dY, CvMat* dE_dX ); 85 86 /*------------------------ functions for sub-sampling layer ----------------------------*/ 87 static void icvCNNSubSamplingRelease( CvCNNLayer** p_layer ); 88 89 static void icvCNNSubSamplingForward( CvCNNLayer* layer, const CvMat* X, CvMat* Y ); 90 91 static void icvCNNSubSamplingBackward( CvCNNLayer* layer, int t, 92 const CvMat* X, const CvMat* dE_dY, CvMat* dE_dX ); 93 94 /*------------------------ functions for full connected layer --------------------------*/ 95 static void icvCNNFullConnectRelease( CvCNNLayer** p_layer ); 96 97 static void icvCNNFullConnectForward( CvCNNLayer* layer, const CvMat* X, CvMat* Y ); 98 99 static void icvCNNFullConnectBackward( CvCNNLayer* layer, int, 100 const CvMat*, const CvMat* dE_dY, CvMat* dE_dX ); 101 102 /****************************************************************************************\ 103 * Functions implementations * 104 \****************************************************************************************/ 105 106 #define ICV_CHECK_CNN_NETWORK(network) \ 107 { \ 108 CvCNNLayer* first_layer, *layer, *last_layer; \ 109 int n_layers, i; \ 110 if( !network ) \ 111 CV_ERROR( CV_StsNullPtr, \ 112 "Null <network> pointer. Network must be created by user." ); \ 113 n_layers = network->n_layers; \ 114 first_layer = last_layer = network->layers; \ 115 for( i = 0, layer = first_layer; i < n_layers && layer; i++ ) \ 116 { \ 117 if( !ICV_IS_CNN_LAYER(layer) ) \ 118 CV_ERROR( CV_StsNullPtr, "Invalid network" ); \ 119 last_layer = layer; \ 120 layer = layer->next_layer; \ 121 } \ 122 \ 123 if( i == 0 || i != n_layers || first_layer->prev_layer || layer ) \ 124 CV_ERROR( CV_StsNullPtr, "Invalid network" ); \ 125 \ 126 if( first_layer->n_input_planes != 1 ) \ 127 CV_ERROR( CV_StsBadArg, "First layer must contain only one input plane" ); \ 128 \ 129 if( img_size != first_layer->input_height*first_layer->input_width ) \ 130 CV_ERROR( CV_StsBadArg, "Invalid input sizes of the first layer" ); \ 131 \ 132 if( params->etalons->cols != last_layer->n_output_planes* \ 133 last_layer->output_height*last_layer->output_width ) \ 134 CV_ERROR( CV_StsBadArg, "Invalid output sizes of the last layer" ); \ 135 } 136 137 #define ICV_CHECK_CNN_MODEL_PARAMS(params) \ 138 { \ 139 if( !params ) \ 140 CV_ERROR( CV_StsNullPtr, "Null <params> pointer" ); \ 141 \ 142 if( !ICV_IS_MAT_OF_TYPE(params->etalons, CV_32FC1) ) \ 143 CV_ERROR( CV_StsBadArg, "<etalons> must be CV_32FC1 type" ); \ 144 if( params->etalons->rows != cnn_model->cls_labels->cols ) \ 145 CV_ERROR( CV_StsBadArg, "Invalid <etalons> size" ); \ 146 \ 147 if( params->grad_estim_type != CV_CNN_GRAD_ESTIM_RANDOM && \ 148 params->grad_estim_type != CV_CNN_GRAD_ESTIM_BY_WORST_IMG ) \ 149 CV_ERROR( CV_StsBadArg, "Invalid <grad_estim_type>" ); \ 150 \ 151 if( params->start_iter < 0 ) \ 152 CV_ERROR( CV_StsBadArg, "Parameter <start_iter> must be positive or zero" ); \ 153 \ 154 if( params->max_iter < 1 ) \ 155 params->max_iter = 1; \ 156 } 157 158 /****************************************************************************************\ 159 * Classifier functions * 160 \****************************************************************************************/ 161 ML_IMPL CvStatModel* 162 cvTrainCNNClassifier( const CvMat* _train_data, int tflag, 163 const CvMat* _responses, 164 const CvStatModelParams* _params, 165 const CvMat*, const CvMat* _sample_idx, const CvMat*, const CvMat* ) 166 { 167 CvCNNStatModel* cnn_model = 0; 168 const float** out_train_data = 0; 169 CvMat* responses = 0; 170 171 CV_FUNCNAME("cvTrainCNNClassifier"); 172 __BEGIN__; 173 174 int n_images; 175 int img_size; 176 CvCNNStatModelParams* params = (CvCNNStatModelParams*)_params; 177 178 CV_CALL(cnn_model = (CvCNNStatModel*)cvCreateStatModel( 179 CV_STAT_MODEL_MAGIC_VAL|CV_CNN_MAGIC_VAL, sizeof(CvCNNStatModel), 180 icvCNNModelRelease, icvCNNModelPredict, icvCNNModelUpdate )); 181 182 CV_CALL(cvPrepareTrainData( "cvTrainCNNClassifier", 183 _train_data, tflag, _responses, CV_VAR_CATEGORICAL, 184 0, _sample_idx, false, &out_train_data, 185 &n_images, &img_size, &img_size, &responses, 186 &cnn_model->cls_labels, 0 )); 187 188 ICV_CHECK_CNN_MODEL_PARAMS(params); 189 ICV_CHECK_CNN_NETWORK(params->network); 190 191 cnn_model->network = params->network; 192 CV_CALL(cnn_model->etalons = (CvMat*)cvClone( params->etalons )); 193 194 CV_CALL( icvTrainCNNetwork( cnn_model->network, out_train_data, responses, 195 cnn_model->etalons, params->grad_estim_type, params->max_iter, 196 params->start_iter )); 197 198 __END__; 199 200 if( cvGetErrStatus() < 0 && cnn_model ) 201 { 202 cnn_model->release( (CvStatModel**)&cnn_model ); 203 } 204 cvFree( &out_train_data ); 205 cvReleaseMat( &responses ); 206 207 return (CvStatModel*)cnn_model; 208 } 209 210 /****************************************************************************************/ 211 static void icvTrainCNNetwork( CvCNNetwork* network, 212 const float** images, 213 const CvMat* responses, 214 const CvMat* etalons, 215 int grad_estim_type, 216 int max_iter, 217 int start_iter ) 218 { 219 CvMat** X = 0; 220 CvMat** dE_dX = 0; 221 const int n_layers = network->n_layers; 222 int k; 223 224 CV_FUNCNAME("icvTrainCNNetwork"); 225 __BEGIN__; 226 227 CvCNNLayer* first_layer = network->layers; 228 const int img_height = first_layer->input_height; 229 const int img_width = first_layer->input_width; 230 const int img_size = img_width*img_height; 231 const int n_images = responses->cols; 232 CvMat image = cvMat( 1, img_size, CV_32FC1 ); 233 CvCNNLayer* layer; 234 int n; 235 CvRNG rng = cvRNG(-1); 236 237 CV_CALL(X = (CvMat**)cvAlloc( (n_layers+1)*sizeof(CvMat*) )); 238 CV_CALL(dE_dX = (CvMat**)cvAlloc( (n_layers+1)*sizeof(CvMat*) )); 239 memset( X, 0, (n_layers+1)*sizeof(CvMat*) ); 240 memset( dE_dX, 0, (n_layers+1)*sizeof(CvMat*) ); 241 242 CV_CALL(X[0] = cvCreateMat( img_height*img_width,1,CV_32FC1 )); 243 CV_CALL(dE_dX[0] = cvCreateMat( 1, X[0]->rows, CV_32FC1 )); 244 for( k = 0, layer = first_layer; k < n_layers; k++, layer = layer->next_layer ) 245 { 246 CV_CALL(X[k+1] = cvCreateMat( layer->n_output_planes*layer->output_height* 247 layer->output_width, 1, CV_32FC1 )); 248 CV_CALL(dE_dX[k+1] = cvCreateMat( 1, X[k+1]->rows, CV_32FC1 )); 249 } 250 251 for( n = 1; n <= max_iter; n++ ) 252 { 253 float loss, max_loss = 0; 254 int i; 255 int worst_img_idx = -1; 256 int* right_etal_idx = responses->data.i; 257 CvMat etalon; 258 259 // Find the worst image (which produces the greatest loss) or use the random image 260 if( grad_estim_type == CV_CNN_GRAD_ESTIM_BY_WORST_IMG ) 261 { 262 for( i = 0; i < n_images; i++, right_etal_idx++ ) 263 { 264 image.data.fl = (float*)images[i]; 265 cvTranspose( &image, X[0] ); 266 267 for( k = 0, layer = first_layer; k < n_layers; k++, layer = layer->next_layer ) 268 CV_CALL(layer->forward( layer, X[k], X[k+1] )); 269 270 cvTranspose( X[n_layers], dE_dX[n_layers] ); 271 cvGetRow( etalons, &etalon, *right_etal_idx ); 272 loss = (float)cvNorm( dE_dX[n_layers], &etalon ); 273 if( loss > max_loss ) 274 { 275 max_loss = loss; 276 worst_img_idx = i; 277 } 278 } 279 } 280 else 281 worst_img_idx = cvRandInt(&rng) % n_images; 282 283 // Train network on the worst image 284 // 1) Compute the network output on the <image> 285 image.data.fl = (float*)images[worst_img_idx]; 286 CV_CALL(cvTranspose( &image, X[0] )); 287 288 for( k = 0, layer = first_layer; k < n_layers - 1; k++, layer = layer->next_layer ) 289 CV_CALL(layer->forward( layer, X[k], X[k+1] )); 290 CV_CALL(layer->forward( layer, X[k], X[k+1] )); 291 292 // 2) Compute the gradient 293 cvTranspose( X[n_layers], dE_dX[n_layers] ); 294 cvGetRow( etalons, &etalon, responses->data.i[worst_img_idx] ); 295 cvSub( dE_dX[n_layers], &etalon, dE_dX[n_layers] ); 296 297 // 3) Update weights by the gradient descent 298 for( k = n_layers; k > 0; k--, layer = layer->prev_layer ) 299 CV_CALL(layer->backward( layer, n + start_iter, X[k-1], dE_dX[k], dE_dX[k-1] )); 300 } 301 302 __END__; 303 304 for( k = 0; k <= n_layers; k++ ) 305 { 306 cvReleaseMat( &X[k] ); 307 cvReleaseMat( &dE_dX[k] ); 308 } 309 cvFree( &X ); 310 cvFree( &dE_dX ); 311 } 312 313 /****************************************************************************************/ 314 static float icvCNNModelPredict( const CvStatModel* model, 315 const CvMat* _image, 316 CvMat* probs ) 317 { 318 CvMat** X = 0; 319 float* img_data = 0; 320 int n_layers = 0; 321 int best_etal_idx = -1; 322 int k; 323 324 CV_FUNCNAME("icvCNNModelPredict"); 325 __BEGIN__; 326 327 CvCNNStatModel* cnn_model = (CvCNNStatModel*)model; 328 CvCNNLayer* first_layer, *layer = 0; 329 int img_height, img_width, img_size; 330 int nclasses, i; 331 float loss, min_loss = FLT_MAX; 332 float* probs_data; 333 CvMat etalon, image; 334 335 if( !CV_IS_CNN(model) ) 336 CV_ERROR( CV_StsBadArg, "Invalid model" ); 337 338 nclasses = cnn_model->cls_labels->cols; 339 n_layers = cnn_model->network->n_layers; 340 first_layer = cnn_model->network->layers; 341 img_height = first_layer->input_height; 342 img_width = first_layer->input_width; 343 img_size = img_height*img_width; 344 345 cvPreparePredictData( _image, img_size, 0, nclasses, probs, &img_data ); 346 347 CV_CALL(X = (CvMat**)cvAlloc( (n_layers+1)*sizeof(CvMat*) )); 348 memset( X, 0, (n_layers+1)*sizeof(CvMat*) ); 349 350 CV_CALL(X[0] = cvCreateMat( img_size,1,CV_32FC1 )); 351 for( k = 0, layer = first_layer; k < n_layers; k++, layer = layer->next_layer ) 352 { 353 CV_CALL(X[k+1] = cvCreateMat( layer->n_output_planes*layer->output_height* 354 layer->output_width, 1, CV_32FC1 )); 355 } 356 357 image = cvMat( 1, img_size, CV_32FC1, img_data ); 358 cvTranspose( &image, X[0] ); 359 for( k = 0, layer = first_layer; k < n_layers; k++, layer = layer->next_layer ) 360 CV_CALL(layer->forward( layer, X[k], X[k+1] )); 361 362 probs_data = probs ? probs->data.fl : 0; 363 etalon = cvMat( cnn_model->etalons->cols, 1, CV_32FC1, cnn_model->etalons->data.fl ); 364 for( i = 0; i < nclasses; i++, etalon.data.fl += cnn_model->etalons->cols ) 365 { 366 loss = (float)cvNorm( X[n_layers], &etalon ); 367 if( loss < min_loss ) 368 { 369 min_loss = loss; 370 best_etal_idx = i; 371 } 372 if( probs ) 373 *probs_data++ = -loss; 374 } 375 376 if( probs ) 377 { 378 cvExp( probs, probs ); 379 CvScalar sum = cvSum( probs ); 380 cvConvertScale( probs, probs, 1./sum.val[0] ); 381 } 382 383 __END__; 384 385 for( k = 0; k <= n_layers; k++ ) 386 cvReleaseMat( &X[k] ); 387 cvFree( &X ); 388 if( img_data != _image->data.fl ) 389 cvFree( &img_data ); 390 391 return ((float) ((CvCNNStatModel*)model)->cls_labels->data.i[best_etal_idx]); 392 } 393 394 /****************************************************************************************/ 395 static void icvCNNModelUpdate( 396 CvStatModel* _cnn_model, const CvMat* _train_data, int tflag, 397 const CvMat* _responses, const CvStatModelParams* _params, 398 const CvMat*, const CvMat* _sample_idx, 399 const CvMat*, const CvMat* ) 400 { 401 const float** out_train_data = 0; 402 CvMat* responses = 0; 403 CvMat* cls_labels = 0; 404 405 CV_FUNCNAME("icvCNNModelUpdate"); 406 __BEGIN__; 407 408 int n_images, img_size, i; 409 CvCNNStatModelParams* params = (CvCNNStatModelParams*)_params; 410 CvCNNStatModel* cnn_model = (CvCNNStatModel*)_cnn_model; 411 412 if( !CV_IS_CNN(cnn_model) ) 413 CV_ERROR( CV_StsBadArg, "Invalid model" ); 414 415 CV_CALL(cvPrepareTrainData( "cvTrainCNNClassifier", 416 _train_data, tflag, _responses, CV_VAR_CATEGORICAL, 417 0, _sample_idx, false, &out_train_data, 418 &n_images, &img_size, &img_size, &responses, 419 &cls_labels, 0, 0 )); 420 421 ICV_CHECK_CNN_MODEL_PARAMS(params); 422 423 // Number of classes must be the same as when classifiers was created 424 if( !CV_ARE_SIZES_EQ(cls_labels, cnn_model->cls_labels) ) 425 CV_ERROR( CV_StsBadArg, "Number of classes must be left unchanged" ); 426 for( i = 0; i < cls_labels->cols; i++ ) 427 { 428 if( cls_labels->data.i[i] != cnn_model->cls_labels->data.i[i] ) 429 CV_ERROR( CV_StsBadArg, "Number of classes must be left unchanged" ); 430 } 431 432 CV_CALL( icvTrainCNNetwork( cnn_model->network, out_train_data, responses, 433 cnn_model->etalons, params->grad_estim_type, params->max_iter, 434 params->start_iter )); 435 436 __END__; 437 438 cvFree( &out_train_data ); 439 cvReleaseMat( &responses ); 440 } 441 442 /****************************************************************************************/ 443 static void icvCNNModelRelease( CvStatModel** cnn_model ) 444 { 445 CV_FUNCNAME("icvCNNModelRelease"); 446 __BEGIN__; 447 448 CvCNNStatModel* cnn; 449 if( !cnn_model ) 450 CV_ERROR( CV_StsNullPtr, "Null double pointer" ); 451 452 cnn = *(CvCNNStatModel**)cnn_model; 453 454 cvReleaseMat( &cnn->cls_labels ); 455 cvReleaseMat( &cnn->etalons ); 456 cnn->network->release( &cnn->network ); 457 458 cvFree( &cnn ); 459 460 __END__; 461 462 } 463 464 /****************************************************************************************\ 465 * Network functions * 466 \****************************************************************************************/ 467 ML_IMPL CvCNNetwork* cvCreateCNNetwork( CvCNNLayer* first_layer ) 468 { 469 CvCNNetwork* network = 0; 470 471 CV_FUNCNAME( "cvCreateCNNetwork" ); 472 __BEGIN__; 473 474 if( !ICV_IS_CNN_LAYER(first_layer) ) 475 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 476 477 CV_CALL(network = (CvCNNetwork*)cvAlloc( sizeof(CvCNNetwork) )); 478 memset( network, 0, sizeof(CvCNNetwork) ); 479 480 network->layers = first_layer; 481 network->n_layers = 1; 482 network->release = icvCNNetworkRelease; 483 network->add_layer = icvCNNetworkAddLayer; 484 485 __END__; 486 487 if( cvGetErrStatus() < 0 && network ) 488 cvFree( &network ); 489 490 return network; 491 492 } 493 494 /****************************************************************************************/ 495 static void icvCNNetworkAddLayer( CvCNNetwork* network, CvCNNLayer* layer ) 496 { 497 CV_FUNCNAME( "icvCNNetworkAddLayer" ); 498 __BEGIN__; 499 500 CvCNNLayer* prev_layer; 501 502 if( network == NULL ) 503 CV_ERROR( CV_StsNullPtr, "Null <network> pointer" ); 504 505 prev_layer = network->layers; 506 while( prev_layer->next_layer ) 507 prev_layer = prev_layer->next_layer; 508 509 if( ICV_IS_CNN_FULLCONNECT_LAYER(layer) ) 510 { 511 if( layer->n_input_planes != prev_layer->output_width*prev_layer->output_height* 512 prev_layer->n_output_planes ) 513 CV_ERROR( CV_StsBadArg, "Unmatched size of the new layer" ); 514 if( layer->input_height != 1 || layer->output_height != 1 || 515 layer->input_width != 1 || layer->output_width != 1 ) 516 CV_ERROR( CV_StsBadArg, "Invalid size of the new layer" ); 517 } 518 else if( ICV_IS_CNN_CONVOLUTION_LAYER(layer) || ICV_IS_CNN_SUBSAMPLING_LAYER(layer) ) 519 { 520 if( prev_layer->n_output_planes != layer->n_input_planes || 521 prev_layer->output_height != layer->input_height || 522 prev_layer->output_width != layer->input_width ) 523 CV_ERROR( CV_StsBadArg, "Unmatched size of the new layer" ); 524 } 525 else 526 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 527 528 layer->prev_layer = prev_layer; 529 prev_layer->next_layer = layer; 530 network->n_layers++; 531 532 __END__; 533 } 534 535 /****************************************************************************************/ 536 static void icvCNNetworkRelease( CvCNNetwork** network_pptr ) 537 { 538 CV_FUNCNAME( "icvReleaseCNNetwork" ); 539 __BEGIN__; 540 541 CvCNNetwork* network = 0; 542 CvCNNLayer* layer = 0, *next_layer = 0; 543 int k; 544 545 if( network_pptr == NULL ) 546 CV_ERROR( CV_StsBadArg, "Null double pointer" ); 547 if( *network_pptr == NULL ) 548 return; 549 550 network = *network_pptr; 551 layer = network->layers; 552 if( layer == NULL ) 553 CV_ERROR( CV_StsBadArg, "CNN is empty (does not contain any layer)" ); 554 555 // k is the number of the layer to be deleted 556 for( k = 0; k < network->n_layers && layer; k++ ) 557 { 558 next_layer = layer->next_layer; 559 layer->release( &layer ); 560 layer = next_layer; 561 } 562 563 if( k != network->n_layers || layer) 564 CV_ERROR( CV_StsBadArg, "Invalid network" ); 565 566 cvFree( &network ); 567 568 __END__; 569 } 570 571 /****************************************************************************************\ 572 * Layer functions * 573 \****************************************************************************************/ 574 static CvCNNLayer* icvCreateCNNLayer( int layer_type, int header_size, 575 int n_input_planes, int input_height, int input_width, 576 int n_output_planes, int output_height, int output_width, 577 float init_learn_rate, int learn_rate_decrease_type, 578 CvCNNLayerRelease release, CvCNNLayerForward forward, CvCNNLayerBackward backward ) 579 { 580 CvCNNLayer* layer = 0; 581 582 CV_FUNCNAME("icvCreateCNNLayer"); 583 __BEGIN__; 584 585 CV_ASSERT( release && forward && backward ) 586 CV_ASSERT( header_size >= sizeof(CvCNNLayer) ) 587 588 if( n_input_planes < 1 || n_output_planes < 1 || 589 input_height < 1 || input_width < 1 || 590 output_height < 1 || output_width < 1 || 591 input_height < output_height || 592 input_width < output_width ) 593 CV_ERROR( CV_StsBadArg, "Incorrect input or output parameters" ); 594 if( init_learn_rate < FLT_EPSILON ) 595 CV_ERROR( CV_StsBadArg, "Initial learning rate must be positive" ); 596 if( learn_rate_decrease_type != CV_CNN_LEARN_RATE_DECREASE_HYPERBOLICALLY && 597 learn_rate_decrease_type != CV_CNN_LEARN_RATE_DECREASE_SQRT_INV && 598 learn_rate_decrease_type != CV_CNN_LEARN_RATE_DECREASE_LOG_INV ) 599 CV_ERROR( CV_StsBadArg, "Invalid type of learning rate dynamics" ); 600 601 CV_CALL(layer = (CvCNNLayer*)cvAlloc( header_size )); 602 memset( layer, 0, header_size ); 603 604 layer->flags = ICV_CNN_LAYER|layer_type; 605 CV_ASSERT( ICV_IS_CNN_LAYER(layer) ) 606 607 layer->n_input_planes = n_input_planes; 608 layer->input_height = input_height; 609 layer->input_width = input_width; 610 611 layer->n_output_planes = n_output_planes; 612 layer->output_height = output_height; 613 layer->output_width = output_width; 614 615 layer->init_learn_rate = init_learn_rate; 616 layer->learn_rate_decrease_type = learn_rate_decrease_type; 617 618 layer->release = release; 619 layer->forward = forward; 620 layer->backward = backward; 621 622 __END__; 623 624 if( cvGetErrStatus() < 0 && layer) 625 cvFree( &layer ); 626 627 return layer; 628 } 629 630 /****************************************************************************************/ 631 ML_IMPL CvCNNLayer* cvCreateCNNConvolutionLayer( 632 int n_input_planes, int input_height, int input_width, 633 int n_output_planes, int K, 634 float init_learn_rate, int learn_rate_decrease_type, 635 CvMat* connect_mask, CvMat* weights ) 636 637 { 638 CvCNNConvolutionLayer* layer = 0; 639 640 CV_FUNCNAME("cvCreateCNNConvolutionLayer"); 641 __BEGIN__; 642 643 const int output_height = input_height - K + 1; 644 const int output_width = input_width - K + 1; 645 646 if( K < 1 || init_learn_rate <= 0 ) 647 CV_ERROR( CV_StsBadArg, "Incorrect parameters" ); 648 649 CV_CALL(layer = (CvCNNConvolutionLayer*)icvCreateCNNLayer( ICV_CNN_CONVOLUTION_LAYER, 650 sizeof(CvCNNConvolutionLayer), n_input_planes, input_height, input_width, 651 n_output_planes, output_height, output_width, 652 init_learn_rate, learn_rate_decrease_type, 653 icvCNNConvolutionRelease, icvCNNConvolutionForward, icvCNNConvolutionBackward )); 654 655 layer->K = K; 656 CV_CALL(layer->weights = cvCreateMat( n_output_planes, K*K+1, CV_32FC1 )); 657 CV_CALL(layer->connect_mask = cvCreateMat( n_output_planes, n_input_planes, CV_8UC1)); 658 659 if( weights ) 660 { 661 if( !ICV_IS_MAT_OF_TYPE( weights, CV_32FC1 ) ) 662 CV_ERROR( CV_StsBadSize, "Type of initial weights matrix must be CV_32FC1" ); 663 if( !CV_ARE_SIZES_EQ( weights, layer->weights ) ) 664 CV_ERROR( CV_StsBadSize, "Invalid size of initial weights matrix" ); 665 CV_CALL(cvCopy( weights, layer->weights )); 666 } 667 else 668 { 669 CvRNG rng = cvRNG( 0xFFFFFFFF ); 670 cvRandArr( &rng, layer->weights, CV_RAND_UNI, cvRealScalar(-1), cvRealScalar(1) ); 671 } 672 673 if( connect_mask ) 674 { 675 if( !ICV_IS_MAT_OF_TYPE( connect_mask, CV_8UC1 ) ) 676 CV_ERROR( CV_StsBadSize, "Type of connection matrix must be CV_32FC1" ); 677 if( !CV_ARE_SIZES_EQ( connect_mask, layer->connect_mask ) ) 678 CV_ERROR( CV_StsBadSize, "Invalid size of connection matrix" ); 679 CV_CALL(cvCopy( connect_mask, layer->connect_mask )); 680 } 681 else 682 CV_CALL(cvSet( layer->connect_mask, cvRealScalar(1) )); 683 684 __END__; 685 686 if( cvGetErrStatus() < 0 && layer ) 687 { 688 cvReleaseMat( &layer->weights ); 689 cvReleaseMat( &layer->connect_mask ); 690 cvFree( &layer ); 691 } 692 693 return (CvCNNLayer*)layer; 694 } 695 696 /****************************************************************************************/ 697 ML_IMPL CvCNNLayer* cvCreateCNNSubSamplingLayer( 698 int n_input_planes, int input_height, int input_width, 699 int sub_samp_scale, float a, float s, 700 float init_learn_rate, int learn_rate_decrease_type, CvMat* weights ) 701 702 { 703 CvCNNSubSamplingLayer* layer = 0; 704 705 CV_FUNCNAME("cvCreateCNNSubSamplingLayer"); 706 __BEGIN__; 707 708 const int output_height = input_height/sub_samp_scale; 709 const int output_width = input_width/sub_samp_scale; 710 const int n_output_planes = n_input_planes; 711 712 if( sub_samp_scale < 1 || a <= 0 || s <= 0) 713 CV_ERROR( CV_StsBadArg, "Incorrect parameters" ); 714 715 CV_CALL(layer = (CvCNNSubSamplingLayer*)icvCreateCNNLayer( ICV_CNN_SUBSAMPLING_LAYER, 716 sizeof(CvCNNSubSamplingLayer), n_input_planes, input_height, input_width, 717 n_output_planes, output_height, output_width, 718 init_learn_rate, learn_rate_decrease_type, 719 icvCNNSubSamplingRelease, icvCNNSubSamplingForward, icvCNNSubSamplingBackward )); 720 721 layer->sub_samp_scale = sub_samp_scale; 722 layer->a = a; 723 layer->s = s; 724 725 CV_CALL(layer->sumX = 726 cvCreateMat( n_output_planes*output_width*output_height, 1, CV_32FC1 )); 727 CV_CALL(layer->exp2ssumWX = 728 cvCreateMat( n_output_planes*output_width*output_height, 1, CV_32FC1 )); 729 730 cvZero( layer->sumX ); 731 cvZero( layer->exp2ssumWX ); 732 733 CV_CALL(layer->weights = cvCreateMat( n_output_planes, 2, CV_32FC1 )); 734 if( weights ) 735 { 736 if( !ICV_IS_MAT_OF_TYPE( weights, CV_32FC1 ) ) 737 CV_ERROR( CV_StsBadSize, "Type of initial weights matrix must be CV_32FC1" ); 738 if( !CV_ARE_SIZES_EQ( weights, layer->weights ) ) 739 CV_ERROR( CV_StsBadSize, "Invalid size of initial weights matrix" ); 740 CV_CALL(cvCopy( weights, layer->weights )); 741 } 742 else 743 { 744 CvRNG rng = cvRNG( 0xFFFFFFFF ); 745 cvRandArr( &rng, layer->weights, CV_RAND_UNI, cvRealScalar(-1), cvRealScalar(1) ); 746 } 747 748 __END__; 749 750 if( cvGetErrStatus() < 0 && layer ) 751 { 752 cvReleaseMat( &layer->exp2ssumWX ); 753 cvFree( &layer ); 754 } 755 756 return (CvCNNLayer*)layer; 757 } 758 759 /****************************************************************************************/ 760 ML_IMPL CvCNNLayer* cvCreateCNNFullConnectLayer( 761 int n_inputs, int n_outputs, float a, float s, 762 float init_learn_rate, int learn_rate_decrease_type, CvMat* weights ) 763 { 764 CvCNNFullConnectLayer* layer = 0; 765 766 CV_FUNCNAME("cvCreateCNNFullConnectLayer"); 767 __BEGIN__; 768 769 if( a <= 0 || s <= 0 || init_learn_rate <= 0) 770 CV_ERROR( CV_StsBadArg, "Incorrect parameters" ); 771 772 CV_CALL(layer = (CvCNNFullConnectLayer*)icvCreateCNNLayer( ICV_CNN_FULLCONNECT_LAYER, 773 sizeof(CvCNNFullConnectLayer), n_inputs, 1, 1, n_outputs, 1, 1, 774 init_learn_rate, learn_rate_decrease_type, 775 icvCNNFullConnectRelease, icvCNNFullConnectForward, icvCNNFullConnectBackward )); 776 777 layer->a = a; 778 layer->s = s; 779 780 CV_CALL(layer->exp2ssumWX = cvCreateMat( n_outputs, 1, CV_32FC1 )); 781 cvZero( layer->exp2ssumWX ); 782 783 CV_CALL(layer->weights = cvCreateMat( n_outputs, n_inputs+1, CV_32FC1 )); 784 if( weights ) 785 { 786 if( !ICV_IS_MAT_OF_TYPE( weights, CV_32FC1 ) ) 787 CV_ERROR( CV_StsBadSize, "Type of initial weights matrix must be CV_32FC1" ); 788 if( !CV_ARE_SIZES_EQ( weights, layer->weights ) ) 789 CV_ERROR( CV_StsBadSize, "Invalid size of initial weights matrix" ); 790 CV_CALL(cvCopy( weights, layer->weights )); 791 } 792 else 793 { 794 CvRNG rng = cvRNG( 0xFFFFFFFF ); 795 cvRandArr( &rng, layer->weights, CV_RAND_UNI, cvRealScalar(-1), cvRealScalar(1) ); 796 } 797 798 __END__; 799 800 if( cvGetErrStatus() < 0 && layer ) 801 { 802 cvReleaseMat( &layer->exp2ssumWX ); 803 cvReleaseMat( &layer->weights ); 804 cvFree( &layer ); 805 } 806 807 return (CvCNNLayer*)layer; 808 } 809 810 811 /****************************************************************************************\ 812 * Layer FORWARD functions * 813 \****************************************************************************************/ 814 static void icvCNNConvolutionForward( CvCNNLayer* _layer, 815 const CvMat* X, 816 CvMat* Y ) 817 { 818 CV_FUNCNAME("icvCNNConvolutionForward"); 819 820 if( !ICV_IS_CNN_CONVOLUTION_LAYER(_layer) ) 821 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 822 823 {__BEGIN__; 824 825 const CvCNNConvolutionLayer* layer = (CvCNNConvolutionLayer*) _layer; 826 827 const int K = layer->K; 828 const int n_weights_for_Yplane = K*K + 1; 829 830 const int nXplanes = layer->n_input_planes; 831 const int Xheight = layer->input_height; 832 const int Xwidth = layer->input_width ; 833 const int Xsize = Xwidth*Xheight; 834 835 const int nYplanes = layer->n_output_planes; 836 const int Yheight = layer->output_height; 837 const int Ywidth = layer->output_width; 838 const int Ysize = Ywidth*Yheight; 839 840 int xx, yy, ni, no, kx, ky; 841 float *Yplane = 0, *Xplane = 0, *w = 0; 842 uchar* connect_mask_data = 0; 843 844 CV_ASSERT( X->rows == nXplanes*Xsize && X->cols == 1 ); 845 CV_ASSERT( Y->rows == nYplanes*Ysize && Y->cols == 1 ); 846 847 cvSetZero( Y ); 848 849 Yplane = Y->data.fl; 850 connect_mask_data = layer->connect_mask->data.ptr; 851 w = layer->weights->data.fl; 852 for( no = 0; no < nYplanes; no++, Yplane += Ysize, w += n_weights_for_Yplane ) 853 { 854 Xplane = X->data.fl; 855 for( ni = 0; ni < nXplanes; ni++, Xplane += Xsize, connect_mask_data++ ) 856 { 857 if( *connect_mask_data ) 858 { 859 float* Yelem = Yplane; 860 861 // Xheight-K+1 == Yheight && Xwidth-K+1 == Ywidth 862 for( yy = 0; yy < Xheight-K+1; yy++ ) 863 { 864 for( xx = 0; xx < Xwidth-K+1; xx++, Yelem++ ) 865 { 866 float* templ = Xplane+yy*Xwidth+xx; 867 float WX = 0; 868 for( ky = 0; ky < K; ky++, templ += Xwidth-K ) 869 { 870 for( kx = 0; kx < K; kx++, templ++ ) 871 { 872 WX += *templ*w[ky*K+kx]; 873 } 874 } 875 *Yelem += WX + w[K*K]; 876 } 877 } 878 } 879 } 880 } 881 }__END__; 882 } 883 884 /****************************************************************************************/ 885 static void icvCNNSubSamplingForward( CvCNNLayer* _layer, 886 const CvMat* X, 887 CvMat* Y ) 888 { 889 CV_FUNCNAME("icvCNNSubSamplingForward"); 890 891 if( !ICV_IS_CNN_SUBSAMPLING_LAYER(_layer) ) 892 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 893 894 {__BEGIN__; 895 896 const CvCNNSubSamplingLayer* layer = (CvCNNSubSamplingLayer*) _layer; 897 898 const int sub_sampl_scale = layer->sub_samp_scale; 899 const int nplanes = layer->n_input_planes; 900 901 const int Xheight = layer->input_height; 902 const int Xwidth = layer->input_width ; 903 const int Xsize = Xwidth*Xheight; 904 905 const int Yheight = layer->output_height; 906 const int Ywidth = layer->output_width; 907 const int Ysize = Ywidth*Yheight; 908 909 int xx, yy, ni, kx, ky; 910 float* sumX_data = 0, *w = 0; 911 CvMat sumX_sub_col, exp2ssumWX_sub_col; 912 913 CV_ASSERT(X->rows == nplanes*Xsize && X->cols == 1); 914 CV_ASSERT(layer->exp2ssumWX->cols == 1 && layer->exp2ssumWX->rows == nplanes*Ysize); 915 916 // update inner variable layer->exp2ssumWX, which will be used in back-progation 917 cvZero( layer->sumX ); 918 cvZero( layer->exp2ssumWX ); 919 920 for( ky = 0; ky < sub_sampl_scale; ky++ ) 921 for( kx = 0; kx < sub_sampl_scale; kx++ ) 922 { 923 float* Xplane = X->data.fl; 924 sumX_data = layer->sumX->data.fl; 925 for( ni = 0; ni < nplanes; ni++, Xplane += Xsize ) 926 { 927 for( yy = 0; yy < Yheight; yy++ ) 928 for( xx = 0; xx < Ywidth; xx++, sumX_data++ ) 929 *sumX_data += Xplane[((yy+ky)*Xwidth+(xx+kx))]; 930 } 931 } 932 933 w = layer->weights->data.fl; 934 cvGetRows( layer->sumX, &sumX_sub_col, 0, Ysize ); 935 cvGetRows( layer->exp2ssumWX, &exp2ssumWX_sub_col, 0, Ysize ); 936 for( ni = 0; ni < nplanes; ni++, w += 2 ) 937 { 938 CV_CALL(cvConvertScale( &sumX_sub_col, &exp2ssumWX_sub_col, w[0], w[1] )); 939 sumX_sub_col.data.fl += Ysize; 940 exp2ssumWX_sub_col.data.fl += Ysize; 941 } 942 943 CV_CALL(cvScale( layer->exp2ssumWX, layer->exp2ssumWX, 2.0*layer->s )); 944 CV_CALL(cvExp( layer->exp2ssumWX, layer->exp2ssumWX )); 945 CV_CALL(cvMinS( layer->exp2ssumWX, FLT_MAX, layer->exp2ssumWX )); 946 //#ifdef _DEBUG 947 { 948 float* exp2ssumWX_data = layer->exp2ssumWX->data.fl; 949 for( ni = 0; ni < layer->exp2ssumWX->rows; ni++, exp2ssumWX_data++ ) 950 { 951 if( *exp2ssumWX_data == FLT_MAX ) 952 cvSetErrStatus( 1 ); 953 } 954 } 955 //#endif 956 // compute the output variable Y == ( a - 2a/(layer->exp2ssumWX + 1)) 957 CV_CALL(cvAddS( layer->exp2ssumWX, cvRealScalar(1), Y )); 958 CV_CALL(cvDiv( 0, Y, Y, -2.0*layer->a )); 959 CV_CALL(cvAddS( Y, cvRealScalar(layer->a), Y )); 960 961 }__END__; 962 } 963 964 /****************************************************************************************/ 965 static void icvCNNFullConnectForward( CvCNNLayer* _layer, const CvMat* X, CvMat* Y ) 966 { 967 CV_FUNCNAME("icvCNNFullConnectForward"); 968 969 if( !ICV_IS_CNN_FULLCONNECT_LAYER(_layer) ) 970 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 971 972 {__BEGIN__; 973 974 const CvCNNFullConnectLayer* layer = (CvCNNFullConnectLayer*)_layer; 975 CvMat* weights = layer->weights; 976 CvMat sub_weights, bias; 977 978 CV_ASSERT(X->cols == 1 && X->rows == layer->n_input_planes); 979 CV_ASSERT(Y->cols == 1 && Y->rows == layer->n_output_planes); 980 981 CV_CALL(cvGetSubRect( weights, &sub_weights, 982 cvRect(0, 0, weights->cols-1, weights->rows ))); 983 CV_CALL(cvGetCol( weights, &bias, weights->cols-1)); 984 985 // update inner variable layer->exp2ssumWX, which will be used in Back-Propagation 986 CV_CALL(cvGEMM( &sub_weights, X, 2*layer->s, &bias, 2*layer->s, layer->exp2ssumWX )); 987 CV_CALL(cvExp( layer->exp2ssumWX, layer->exp2ssumWX )); 988 CV_CALL(cvMinS( layer->exp2ssumWX, FLT_MAX, layer->exp2ssumWX )); 989 //#ifdef _DEBUG 990 { 991 float* exp2ssumWX_data = layer->exp2ssumWX->data.fl; 992 int i; 993 for( i = 0; i < layer->exp2ssumWX->rows; i++, exp2ssumWX_data++ ) 994 { 995 if( *exp2ssumWX_data == FLT_MAX ) 996 cvSetErrStatus( 1 ); 997 } 998 } 999 //#endif 1000 // compute the output variable Y == ( a - 2a/(layer->exp2ssumWX + 1)) 1001 CV_CALL(cvAddS( layer->exp2ssumWX, cvRealScalar(1), Y )); 1002 CV_CALL(cvDiv( 0, Y, Y, -2.0*layer->a )); 1003 CV_CALL(cvAddS( Y, cvRealScalar(layer->a), Y )); 1004 1005 }__END__; 1006 } 1007 1008 /****************************************************************************************\ 1009 * Layer BACKWARD functions * 1010 \****************************************************************************************/ 1011 1012 /* <dE_dY>, <dE_dX> should be row-vectors. 1013 Function computes partial derivatives <dE_dX> 1014 of the loss function with respect to the planes components 1015 of the previous layer (X). 1016 It is a basic function for back propagation method. 1017 Input parameter <dE_dY> is the partial derivative of the 1018 loss function with respect to the planes components 1019 of the current layer. */ 1020 static void icvCNNConvolutionBackward( 1021 CvCNNLayer* _layer, int t, const CvMat* X, const CvMat* dE_dY, CvMat* dE_dX ) 1022 { 1023 CvMat* dY_dX = 0; 1024 CvMat* dY_dW = 0; 1025 CvMat* dE_dW = 0; 1026 1027 CV_FUNCNAME("icvCNNConvolutionBackward"); 1028 1029 if( !ICV_IS_CNN_CONVOLUTION_LAYER(_layer) ) 1030 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 1031 1032 {__BEGIN__; 1033 1034 const CvCNNConvolutionLayer* layer = (CvCNNConvolutionLayer*) _layer; 1035 1036 const int K = layer->K; 1037 1038 const int n_X_planes = layer->n_input_planes; 1039 const int X_plane_height = layer->input_height; 1040 const int X_plane_width = layer->input_width; 1041 const int X_plane_size = X_plane_height*X_plane_width; 1042 1043 const int n_Y_planes = layer->n_output_planes; 1044 const int Y_plane_height = layer->output_height; 1045 const int Y_plane_width = layer->output_width; 1046 const int Y_plane_size = Y_plane_height*Y_plane_width; 1047 1048 int no, ni, yy, xx, ky, kx; 1049 int X_idx = 0, Y_idx = 0; 1050 1051 float *X_plane = 0, *w = 0; 1052 1053 CvMat* weights = layer->weights; 1054 1055 CV_ASSERT( t >= 1 ); 1056 CV_ASSERT( n_Y_planes == weights->rows ); 1057 1058 dY_dX = cvCreateMat( n_Y_planes*Y_plane_size, X->rows, CV_32FC1 ); 1059 dY_dW = cvCreateMat( dY_dX->rows, weights->cols*weights->rows, CV_32FC1 ); 1060 dE_dW = cvCreateMat( 1, dY_dW->cols, CV_32FC1 ); 1061 1062 cvZero( dY_dX ); 1063 cvZero( dY_dW ); 1064 1065 // compute gradient of the loss function with respect to X and W 1066 for( no = 0; no < n_Y_planes; no++, Y_idx += Y_plane_size ) 1067 { 1068 w = weights->data.fl + no*(K*K+1); 1069 X_idx = 0; 1070 X_plane = X->data.fl; 1071 for( ni = 0; ni < n_X_planes; ni++, X_plane += X_plane_size ) 1072 { 1073 if( layer->connect_mask->data.ptr[ni*n_Y_planes+no] ) 1074 { 1075 for( yy = 0; yy < X_plane_height - K + 1; yy++ ) 1076 { 1077 for( xx = 0; xx < X_plane_width - K + 1; xx++ ) 1078 { 1079 for( ky = 0; ky < K; ky++ ) 1080 { 1081 for( kx = 0; kx < K; kx++ ) 1082 { 1083 CV_MAT_ELEM(*dY_dX, float, Y_idx+yy*Y_plane_width+xx, 1084 X_idx+(yy+ky)*X_plane_width+(xx+kx)) = w[ky*K+kx]; 1085 1086 // dY_dWi, i=1,...,K*K 1087 CV_MAT_ELEM(*dY_dW, float, Y_idx+yy*Y_plane_width+xx, 1088 no*(K*K+1)+ky*K+kx) += 1089 X_plane[(yy+ky)*X_plane_width+(xx+kx)]; 1090 } 1091 } 1092 // dY_dW(K*K+1)==1 because W(K*K+1) is bias 1093 CV_MAT_ELEM(*dY_dW, float, Y_idx+yy*Y_plane_width+xx, 1094 no*(K*K+1)+K*K) += 1; 1095 } 1096 } 1097 } 1098 X_idx += X_plane_size; 1099 } 1100 } 1101 1102 CV_CALL(cvMatMul( dE_dY, dY_dW, dE_dW )); 1103 CV_CALL(cvMatMul( dE_dY, dY_dX, dE_dX )); 1104 1105 // update weights 1106 { 1107 CvMat dE_dW_mat; 1108 float eta; 1109 if( layer->learn_rate_decrease_type == CV_CNN_LEARN_RATE_DECREASE_LOG_INV ) 1110 eta = -layer->init_learn_rate/logf(1+(float)t); 1111 else if( layer->learn_rate_decrease_type == CV_CNN_LEARN_RATE_DECREASE_SQRT_INV ) 1112 eta = -layer->init_learn_rate/sqrtf((float)t); 1113 else 1114 eta = -layer->init_learn_rate/(float)t; 1115 cvReshape( dE_dW, &dE_dW_mat, 0, weights->rows ); 1116 cvScaleAdd( &dE_dW_mat, cvRealScalar(eta), weights, weights ); 1117 } 1118 1119 }__END__; 1120 1121 cvReleaseMat( &dY_dX ); 1122 cvReleaseMat( &dY_dW ); 1123 cvReleaseMat( &dE_dW ); 1124 } 1125 1126 /****************************************************************************************/ 1127 static void icvCNNSubSamplingBackward( 1128 CvCNNLayer* _layer, int t, const CvMat*, const CvMat* dE_dY, CvMat* dE_dX ) 1129 { 1130 // derivative of activation function 1131 CvMat* dY_dX_elems = 0; // elements of matrix dY_dX 1132 CvMat* dY_dW_elems = 0; // elements of matrix dY_dW 1133 CvMat* dE_dW = 0; 1134 1135 CV_FUNCNAME("icvCNNSubSamplingBackward"); 1136 1137 if( !ICV_IS_CNN_SUBSAMPLING_LAYER(_layer) ) 1138 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 1139 1140 {__BEGIN__; 1141 1142 const CvCNNSubSamplingLayer* layer = (CvCNNSubSamplingLayer*) _layer; 1143 1144 const int Xwidth = layer->input_width; 1145 const int Ywidth = layer->output_width; 1146 const int Yheight = layer->output_height; 1147 const int Ysize = Ywidth * Yheight; 1148 const int scale = layer->sub_samp_scale; 1149 const int k_max = layer->n_output_planes * Yheight; 1150 1151 int k, i, j, m; 1152 float* dY_dX_current_elem = 0, *dE_dX_start = 0, *dE_dW_data = 0, *w = 0; 1153 CvMat dy_dw0, dy_dw1; 1154 CvMat activ_func_der, sumX_row; 1155 CvMat dE_dY_sub_row, dY_dX_sub_col, dy_dw0_sub_row, dy_dw1_sub_row; 1156 1157 CV_CALL(dY_dX_elems = cvCreateMat( layer->sumX->rows, 1, CV_32FC1 )); 1158 CV_CALL(dY_dW_elems = cvCreateMat( 2, layer->sumX->rows, CV_32FC1 )); 1159 CV_CALL(dE_dW = cvCreateMat( 1, 2*layer->n_output_planes, CV_32FC1 )); 1160 1161 // compute derivative of activ.func. 1162 // ==<dY_dX_elems> = 4as*(layer->exp2ssumWX)/(layer->exp2ssumWX + 1)^2 1163 CV_CALL(cvAddS( layer->exp2ssumWX, cvRealScalar(1), dY_dX_elems )); 1164 CV_CALL(cvPow( dY_dX_elems, dY_dX_elems, -2.0 )); 1165 CV_CALL(cvMul( dY_dX_elems, layer->exp2ssumWX, dY_dX_elems, 4.0*layer->a*layer->s )); 1166 1167 // compute <dE_dW> 1168 // a) compute <dY_dW_elems> 1169 cvReshape( dY_dX_elems, &activ_func_der, 0, 1 ); 1170 cvGetRow( dY_dW_elems, &dy_dw0, 0 ); 1171 cvGetRow( dY_dW_elems, &dy_dw1, 1 ); 1172 CV_CALL(cvCopy( &activ_func_der, &dy_dw0 )); 1173 CV_CALL(cvCopy( &activ_func_der, &dy_dw1 )); 1174 1175 cvReshape( layer->sumX, &sumX_row, 0, 1 ); 1176 cvMul( &dy_dw0, &sumX_row, &dy_dw0 ); 1177 1178 // b) compute <dE_dW> = <dE_dY>*<dY_dW_elems> 1179 cvGetCols( dE_dY, &dE_dY_sub_row, 0, Ysize ); 1180 cvGetCols( &dy_dw0, &dy_dw0_sub_row, 0, Ysize ); 1181 cvGetCols( &dy_dw1, &dy_dw1_sub_row, 0, Ysize ); 1182 dE_dW_data = dE_dW->data.fl; 1183 for( i = 0; i < layer->n_output_planes; i++ ) 1184 { 1185 *dE_dW_data++ = (float)cvDotProduct( &dE_dY_sub_row, &dy_dw0_sub_row ); 1186 *dE_dW_data++ = (float)cvDotProduct( &dE_dY_sub_row, &dy_dw1_sub_row ); 1187 1188 dE_dY_sub_row.data.fl += Ysize; 1189 dy_dw0_sub_row.data.fl += Ysize; 1190 dy_dw1_sub_row.data.fl += Ysize; 1191 } 1192 1193 // compute <dY_dX> = layer->weights*<dY_dX> 1194 w = layer->weights->data.fl; 1195 cvGetRows( dY_dX_elems, &dY_dX_sub_col, 0, Ysize ); 1196 for( i = 0; i < layer->n_input_planes; i++, w++, dY_dX_sub_col.data.fl += Ysize ) 1197 CV_CALL(cvConvertScale( &dY_dX_sub_col, &dY_dX_sub_col, (float)*w )); 1198 1199 // compute <dE_dX> 1200 CV_CALL(cvReshape( dY_dX_elems, dY_dX_elems, 0, 1 )); 1201 CV_CALL(cvMul( dY_dX_elems, dE_dY, dY_dX_elems )); 1202 1203 dY_dX_current_elem = dY_dX_elems->data.fl; 1204 dE_dX_start = dE_dX->data.fl; 1205 for( k = 0; k < k_max; k++ ) 1206 { 1207 for( i = 0; i < Ywidth; i++, dY_dX_current_elem++ ) 1208 { 1209 float* dE_dX_current_elem = dE_dX_start; 1210 for( j = 0; j < scale; j++, dE_dX_current_elem += Xwidth - scale ) 1211 { 1212 for( m = 0; m < scale; m++, dE_dX_current_elem++ ) 1213 *dE_dX_current_elem = *dY_dX_current_elem; 1214 } 1215 dE_dX_start += scale; 1216 } 1217 dE_dX_start += Xwidth * (scale - 1); 1218 } 1219 1220 // update weights 1221 { 1222 CvMat dE_dW_mat, *weights = layer->weights; 1223 float eta; 1224 if( layer->learn_rate_decrease_type == CV_CNN_LEARN_RATE_DECREASE_LOG_INV ) 1225 eta = -layer->init_learn_rate/logf(1+(float)t); 1226 else if( layer->learn_rate_decrease_type == CV_CNN_LEARN_RATE_DECREASE_SQRT_INV ) 1227 eta = -layer->init_learn_rate/sqrtf((float)t); 1228 else 1229 eta = -layer->init_learn_rate/(float)t; 1230 cvReshape( dE_dW, &dE_dW_mat, 0, weights->rows ); 1231 cvScaleAdd( &dE_dW_mat, cvRealScalar(eta), weights, weights ); 1232 } 1233 1234 }__END__; 1235 1236 cvReleaseMat( &dY_dX_elems ); 1237 cvReleaseMat( &dY_dW_elems ); 1238 cvReleaseMat( &dE_dW ); 1239 } 1240 1241 /****************************************************************************************/ 1242 /* <dE_dY>, <dE_dX> should be row-vectors. 1243 Function computes partial derivatives <dE_dX>, <dE_dW> 1244 of the loss function with respect to the planes components 1245 of the previous layer (X) and the weights of the current layer (W) 1246 and updates weights od the current layer by using <dE_dW>. 1247 It is a basic function for back propagation method. 1248 Input parameter <dE_dY> is the partial derivative of the 1249 loss function with respect to the planes components 1250 of the current layer. */ 1251 static void icvCNNFullConnectBackward( CvCNNLayer* _layer, 1252 int t, 1253 const CvMat* X, 1254 const CvMat* dE_dY, 1255 CvMat* dE_dX ) 1256 { 1257 CvMat* dE_dY_activ_func_der = 0; 1258 CvMat* dE_dW = 0; 1259 1260 CV_FUNCNAME( "icvCNNFullConnectBackward" ); 1261 1262 if( !ICV_IS_CNN_FULLCONNECT_LAYER(_layer) ) 1263 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 1264 1265 {__BEGIN__; 1266 1267 const CvCNNFullConnectLayer* layer = (CvCNNFullConnectLayer*)_layer; 1268 const int n_outputs = layer->n_output_planes; 1269 const int n_inputs = layer->n_input_planes; 1270 1271 int i; 1272 float* dE_dY_activ_func_der_data; 1273 CvMat* weights = layer->weights; 1274 CvMat sub_weights, Xtemplate, Xrow, exp2ssumWXrow; 1275 1276 CV_ASSERT(X->cols == 1 && X->rows == n_inputs); 1277 CV_ASSERT(dE_dY->rows == 1 && dE_dY->cols == n_outputs ); 1278 CV_ASSERT(dE_dX->rows == 1 && dE_dX->cols == n_inputs ); 1279 1280 // we violate the convetion about vector's orientation because 1281 // here is more convenient to make this parameter a row-vector 1282 CV_CALL(dE_dY_activ_func_der = cvCreateMat( 1, n_outputs, CV_32FC1 )); 1283 CV_CALL(dE_dW = cvCreateMat( 1, weights->rows*weights->cols, CV_32FC1 )); 1284 1285 // 1) compute gradients dE_dX and dE_dW 1286 // activ_func_der == 4as*(layer->exp2ssumWX)/(layer->exp2ssumWX + 1)^2 1287 CV_CALL(cvReshape( layer->exp2ssumWX, &exp2ssumWXrow, 0, layer->exp2ssumWX->cols )); 1288 CV_CALL(cvAddS( &exp2ssumWXrow, cvRealScalar(1), dE_dY_activ_func_der )); 1289 CV_CALL(cvPow( dE_dY_activ_func_der, dE_dY_activ_func_der, -2.0 )); 1290 CV_CALL(cvMul( dE_dY_activ_func_der, &exp2ssumWXrow, dE_dY_activ_func_der, 1291 4.0*layer->a*layer->s )); 1292 CV_CALL(cvMul( dE_dY, dE_dY_activ_func_der, dE_dY_activ_func_der )); 1293 1294 // sub_weights = d(W*(X|1))/dX 1295 CV_CALL(cvGetSubRect( weights, &sub_weights, 1296 cvRect(0, 0, weights->cols-1, weights->rows) )); 1297 CV_CALL(cvMatMul( dE_dY_activ_func_der, &sub_weights, dE_dX )); 1298 1299 cvReshape( X, &Xrow, 0, 1 ); 1300 dE_dY_activ_func_der_data = dE_dY_activ_func_der->data.fl; 1301 Xtemplate = cvMat( 1, n_inputs, CV_32FC1, dE_dW->data.fl ); 1302 for( i = 0; i < n_outputs; i++, Xtemplate.data.fl += n_inputs + 1 ) 1303 { 1304 CV_CALL(cvConvertScale( &Xrow, &Xtemplate, *dE_dY_activ_func_der_data )); 1305 Xtemplate.data.fl[n_inputs] = *dE_dY_activ_func_der_data++; 1306 } 1307 1308 // 2) update weights 1309 { 1310 CvMat dE_dW_mat; 1311 float eta; 1312 if( layer->learn_rate_decrease_type == CV_CNN_LEARN_RATE_DECREASE_LOG_INV ) 1313 eta = -layer->init_learn_rate/logf(1+(float)t); 1314 else if( layer->learn_rate_decrease_type == CV_CNN_LEARN_RATE_DECREASE_SQRT_INV ) 1315 eta = -layer->init_learn_rate/sqrtf((float)t); 1316 else 1317 eta = -layer->init_learn_rate/(float)t; 1318 cvReshape( dE_dW, &dE_dW_mat, 0, n_outputs ); 1319 cvScaleAdd( &dE_dW_mat, cvRealScalar(eta), weights, weights ); 1320 } 1321 1322 }__END__; 1323 1324 cvReleaseMat( &dE_dY_activ_func_der ); 1325 cvReleaseMat( &dE_dW ); 1326 } 1327 1328 /****************************************************************************************\ 1329 * Layer RELEASE functions * 1330 \****************************************************************************************/ 1331 static void icvCNNConvolutionRelease( CvCNNLayer** p_layer ) 1332 { 1333 CV_FUNCNAME("icvCNNConvolutionRelease"); 1334 __BEGIN__; 1335 1336 CvCNNConvolutionLayer* layer = 0; 1337 1338 if( !p_layer ) 1339 CV_ERROR( CV_StsNullPtr, "Null double pointer" ); 1340 1341 layer = *(CvCNNConvolutionLayer**)p_layer; 1342 1343 if( !layer ) 1344 return; 1345 if( !ICV_IS_CNN_CONVOLUTION_LAYER(layer) ) 1346 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 1347 1348 cvReleaseMat( &layer->weights ); 1349 cvReleaseMat( &layer->connect_mask ); 1350 cvFree( p_layer ); 1351 1352 __END__; 1353 } 1354 1355 /****************************************************************************************/ 1356 static void icvCNNSubSamplingRelease( CvCNNLayer** p_layer ) 1357 { 1358 CV_FUNCNAME("icvCNNSubSamplingRelease"); 1359 __BEGIN__; 1360 1361 CvCNNSubSamplingLayer* layer = 0; 1362 1363 if( !p_layer ) 1364 CV_ERROR( CV_StsNullPtr, "Null double pointer" ); 1365 1366 layer = *(CvCNNSubSamplingLayer**)p_layer; 1367 1368 if( !layer ) 1369 return; 1370 if( !ICV_IS_CNN_SUBSAMPLING_LAYER(layer) ) 1371 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 1372 1373 cvReleaseMat( &layer->exp2ssumWX ); 1374 cvReleaseMat( &layer->weights ); 1375 cvFree( p_layer ); 1376 1377 __END__; 1378 } 1379 1380 /****************************************************************************************/ 1381 static void icvCNNFullConnectRelease( CvCNNLayer** p_layer ) 1382 { 1383 CV_FUNCNAME("icvCNNFullConnectRelease"); 1384 __BEGIN__; 1385 1386 CvCNNFullConnectLayer* layer = 0; 1387 1388 if( !p_layer ) 1389 CV_ERROR( CV_StsNullPtr, "Null double pointer" ); 1390 1391 layer = *(CvCNNFullConnectLayer**)p_layer; 1392 1393 if( !layer ) 1394 return; 1395 if( !ICV_IS_CNN_FULLCONNECT_LAYER(layer) ) 1396 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 1397 1398 cvReleaseMat( &layer->exp2ssumWX ); 1399 cvReleaseMat( &layer->weights ); 1400 cvFree( p_layer ); 1401 1402 __END__; 1403 } 1404 1405 /****************************************************************************************\ 1406 * Read/Write CNN classifier * 1407 \****************************************************************************************/ 1408 static int icvIsCNNModel( const void* ptr ) 1409 { 1410 return CV_IS_CNN(ptr); 1411 } 1412 1413 /****************************************************************************************/ 1414 static void icvReleaseCNNModel( void** ptr ) 1415 { 1416 CV_FUNCNAME("icvReleaseCNNModel"); 1417 __BEGIN__; 1418 1419 if( !ptr ) 1420 CV_ERROR( CV_StsNullPtr, "NULL double pointer" ); 1421 CV_ASSERT(CV_IS_CNN(*ptr)); 1422 1423 icvCNNModelRelease( (CvStatModel**)ptr ); 1424 1425 __END__; 1426 } 1427 1428 /****************************************************************************************/ 1429 static CvCNNLayer* icvReadCNNLayer( CvFileStorage* fs, CvFileNode* node ) 1430 { 1431 CvCNNLayer* layer = 0; 1432 CvMat* weights = 0; 1433 CvMat* connect_mask = 0; 1434 1435 CV_FUNCNAME("icvReadCNNLayer"); 1436 __BEGIN__; 1437 1438 int n_input_planes, input_height, input_width; 1439 int n_output_planes, output_height, output_width; 1440 int learn_type, layer_type; 1441 float init_learn_rate; 1442 1443 CV_CALL(n_input_planes = cvReadIntByName( fs, node, "n_input_planes", -1 )); 1444 CV_CALL(input_height = cvReadIntByName( fs, node, "input_height", -1 )); 1445 CV_CALL(input_width = cvReadIntByName( fs, node, "input_width", -1 )); 1446 CV_CALL(n_output_planes = cvReadIntByName( fs, node, "n_output_planes", -1 )); 1447 CV_CALL(output_height = cvReadIntByName( fs, node, "output_height", -1 )); 1448 CV_CALL(output_width = cvReadIntByName( fs, node, "output_width", -1 )); 1449 CV_CALL(layer_type = cvReadIntByName( fs, node, "layer_type", -1 )); 1450 1451 CV_CALL(init_learn_rate = (float)cvReadRealByName( fs, node, "init_learn_rate", -1 )); 1452 CV_CALL(learn_type = cvReadIntByName( fs, node, "learn_rate_decrease_type", -1 )); 1453 CV_CALL(weights = (CvMat*)cvReadByName( fs, node, "weights" )); 1454 1455 if( n_input_planes < 0 || input_height < 0 || input_width < 0 || 1456 n_output_planes < 0 || output_height < 0 || output_width < 0 || 1457 init_learn_rate < 0 || learn_type < 0 || layer_type < 0 || !weights ) 1458 CV_ERROR( CV_StsParseError, "" ); 1459 1460 if( layer_type == ICV_CNN_CONVOLUTION_LAYER ) 1461 { 1462 const int K = input_height - output_height + 1; 1463 if( K <= 0 || K != input_width - output_width + 1 ) 1464 CV_ERROR( CV_StsBadArg, "Invalid <K>" ); 1465 1466 CV_CALL(connect_mask = (CvMat*)cvReadByName( fs, node, "connect_mask" )); 1467 if( !connect_mask ) 1468 CV_ERROR( CV_StsParseError, "Missing <connect mask>" ); 1469 1470 CV_CALL(layer = cvCreateCNNConvolutionLayer( 1471 n_input_planes, input_height, input_width, n_output_planes, K, 1472 init_learn_rate, learn_type, connect_mask, weights )); 1473 } 1474 else if( layer_type == ICV_CNN_SUBSAMPLING_LAYER ) 1475 { 1476 float a, s; 1477 const int sub_samp_scale = input_height/output_height; 1478 1479 if( sub_samp_scale <= 0 || sub_samp_scale != input_width/output_width ) 1480 CV_ERROR( CV_StsBadArg, "Invalid <sub_samp_scale>" ); 1481 1482 CV_CALL(a = (float)cvReadRealByName( fs, node, "a", -1 )); 1483 CV_CALL(s = (float)cvReadRealByName( fs, node, "s", -1 )); 1484 if( a < 0 || s < 0 ) 1485 CV_ERROR( CV_StsParseError, "Missing <a> or <s>" ); 1486 1487 CV_CALL(layer = cvCreateCNNSubSamplingLayer( 1488 n_input_planes, input_height, input_width, sub_samp_scale, 1489 a, s, init_learn_rate, learn_type, weights )); 1490 } 1491 else if( layer_type == ICV_CNN_FULLCONNECT_LAYER ) 1492 { 1493 float a, s; 1494 CV_CALL(a = (float)cvReadRealByName( fs, node, "a", -1 )); 1495 CV_CALL(s = (float)cvReadRealByName( fs, node, "s", -1 )); 1496 if( a < 0 || s < 0 ) 1497 CV_ERROR( CV_StsParseError, "" ); 1498 if( input_height != 1 || input_width != 1 || 1499 output_height != 1 || output_width != 1 ) 1500 CV_ERROR( CV_StsBadArg, "" ); 1501 1502 CV_CALL(layer = cvCreateCNNFullConnectLayer( n_input_planes, n_output_planes, 1503 a, s, init_learn_rate, learn_type, weights )); 1504 } 1505 else 1506 CV_ERROR( CV_StsBadArg, "Invalid <layer_type>" ); 1507 1508 __END__; 1509 1510 if( cvGetErrStatus() < 0 && layer ) 1511 layer->release( &layer ); 1512 1513 cvReleaseMat( &weights ); 1514 cvReleaseMat( &connect_mask ); 1515 1516 return layer; 1517 } 1518 1519 /****************************************************************************************/ 1520 static void icvWriteCNNLayer( CvFileStorage* fs, CvCNNLayer* layer ) 1521 { 1522 CV_FUNCNAME ("icvWriteCNNLayer"); 1523 __BEGIN__; 1524 1525 if( !ICV_IS_CNN_LAYER(layer) ) 1526 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 1527 1528 CV_CALL( cvStartWriteStruct( fs, NULL, CV_NODE_MAP, "opencv-ml-cnn-layer" )); 1529 1530 CV_CALL(cvWriteInt( fs, "n_input_planes", layer->n_input_planes )); 1531 CV_CALL(cvWriteInt( fs, "input_height", layer->input_height )); 1532 CV_CALL(cvWriteInt( fs, "input_width", layer->input_width )); 1533 CV_CALL(cvWriteInt( fs, "n_output_planes", layer->n_output_planes )); 1534 CV_CALL(cvWriteInt( fs, "output_height", layer->output_height )); 1535 CV_CALL(cvWriteInt( fs, "output_width", layer->output_width )); 1536 CV_CALL(cvWriteInt( fs, "learn_rate_decrease_type", layer->learn_rate_decrease_type)); 1537 CV_CALL(cvWriteReal( fs, "init_learn_rate", layer->init_learn_rate )); 1538 CV_CALL(cvWrite( fs, "weights", layer->weights )); 1539 1540 if( ICV_IS_CNN_CONVOLUTION_LAYER( layer )) 1541 { 1542 CvCNNConvolutionLayer* l = (CvCNNConvolutionLayer*)layer; 1543 CV_CALL(cvWriteInt( fs, "layer_type", ICV_CNN_CONVOLUTION_LAYER )); 1544 CV_CALL(cvWrite( fs, "connect_mask", l->connect_mask )); 1545 } 1546 else if( ICV_IS_CNN_SUBSAMPLING_LAYER( layer ) ) 1547 { 1548 CvCNNSubSamplingLayer* l = (CvCNNSubSamplingLayer*)layer; 1549 CV_CALL(cvWriteInt( fs, "layer_type", ICV_CNN_SUBSAMPLING_LAYER )); 1550 CV_CALL(cvWriteReal( fs, "a", l->a )); 1551 CV_CALL(cvWriteReal( fs, "s", l->s )); 1552 } 1553 else if( ICV_IS_CNN_FULLCONNECT_LAYER( layer ) ) 1554 { 1555 CvCNNFullConnectLayer* l = (CvCNNFullConnectLayer*)layer; 1556 CV_CALL(cvWriteInt( fs, "layer_type", ICV_CNN_FULLCONNECT_LAYER )); 1557 CV_CALL(cvWriteReal( fs, "a", l->a )); 1558 CV_CALL(cvWriteReal( fs, "s", l->s )); 1559 } 1560 else 1561 CV_ERROR( CV_StsBadArg, "Invalid layer" ); 1562 1563 CV_CALL( cvEndWriteStruct( fs )); //"opencv-ml-cnn-layer" 1564 1565 __END__; 1566 } 1567 1568 /****************************************************************************************/ 1569 static void* icvReadCNNModel( CvFileStorage* fs, CvFileNode* root_node ) 1570 { 1571 CvCNNStatModel* cnn = 0; 1572 CvCNNLayer* layer = 0; 1573 1574 CV_FUNCNAME("icvReadCNNModel"); 1575 __BEGIN__; 1576 1577 CvFileNode* node; 1578 CvSeq* seq; 1579 CvSeqReader reader; 1580 int i; 1581 1582 CV_CALL(cnn = (CvCNNStatModel*)cvCreateStatModel( 1583 CV_STAT_MODEL_MAGIC_VAL|CV_CNN_MAGIC_VAL, sizeof(CvCNNStatModel), 1584 icvCNNModelRelease, icvCNNModelPredict, icvCNNModelUpdate )); 1585 1586 CV_CALL(cnn->etalons = (CvMat*)cvReadByName( fs, root_node, "etalons" )); 1587 CV_CALL(cnn->cls_labels = (CvMat*)cvReadByName( fs, root_node, "cls_labels" )); 1588 1589 if( !cnn->etalons || !cnn->cls_labels ) 1590 CV_ERROR( CV_StsParseError, "No <etalons> or <cls_labels> in CNN model" ); 1591 1592 CV_CALL( node = cvGetFileNodeByName( fs, root_node, "network" )); 1593 seq = node->data.seq; 1594 if( !CV_NODE_IS_SEQ(node->tag) ) 1595 CV_ERROR( CV_StsBadArg, "" ); 1596 1597 CV_CALL( cvStartReadSeq( seq, &reader, 0 )); 1598 CV_CALL(layer = icvReadCNNLayer( fs, (CvFileNode*)reader.ptr )); 1599 CV_CALL(cnn->network = cvCreateCNNetwork( layer )); 1600 1601 for( i = 1; i < seq->total; i++ ) 1602 { 1603 CV_NEXT_SEQ_ELEM( seq->elem_size, reader ); 1604 CV_CALL(layer = icvReadCNNLayer( fs, (CvFileNode*)reader.ptr )); 1605 CV_CALL(cnn->network->add_layer( cnn->network, layer )); 1606 } 1607 1608 __END__; 1609 1610 if( cvGetErrStatus() < 0 ) 1611 { 1612 if( cnn ) cnn->release( (CvStatModel**)&cnn ); 1613 if( layer ) layer->release( &layer ); 1614 } 1615 return (void*)cnn; 1616 } 1617 1618 /****************************************************************************************/ 1619 static void 1620 icvWriteCNNModel( CvFileStorage* fs, const char* name, 1621 const void* struct_ptr, CvAttrList ) 1622 1623 { 1624 CV_FUNCNAME ("icvWriteCNNModel"); 1625 __BEGIN__; 1626 1627 CvCNNStatModel* cnn = (CvCNNStatModel*)struct_ptr; 1628 int n_layers, i; 1629 CvCNNLayer* layer; 1630 1631 if( !CV_IS_CNN(cnn) ) 1632 CV_ERROR( CV_StsBadArg, "Invalid pointer" ); 1633 1634 n_layers = cnn->network->n_layers; 1635 1636 CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_CNN )); 1637 1638 CV_CALL(cvWrite( fs, "etalons", cnn->etalons )); 1639 CV_CALL(cvWrite( fs, "cls_labels", cnn->cls_labels )); 1640 1641 CV_CALL( cvStartWriteStruct( fs, "network", CV_NODE_SEQ )); 1642 1643 layer = cnn->network->layers; 1644 for( i = 0; i < n_layers && layer; i++, layer = layer->next_layer ) 1645 CV_CALL(icvWriteCNNLayer( fs, layer )); 1646 if( i < n_layers || layer ) 1647 CV_ERROR( CV_StsBadArg, "Invalid network" ); 1648 1649 CV_CALL( cvEndWriteStruct( fs )); //"network" 1650 CV_CALL( cvEndWriteStruct( fs )); //"opencv-ml-cnn" 1651 1652 __END__; 1653 } 1654 1655 static int icvRegisterCNNStatModelType() 1656 { 1657 CvTypeInfo info; 1658 1659 info.header_size = sizeof( info ); 1660 info.is_instance = icvIsCNNModel; 1661 info.release = icvReleaseCNNModel; 1662 info.read = icvReadCNNModel; 1663 info.write = icvWriteCNNModel; 1664 info.clone = NULL; 1665 info.type_name = CV_TYPE_NAME_ML_CNN; 1666 cvRegisterType( &info ); 1667 1668 return 1; 1669 } // End of icvRegisterCNNStatModelType 1670 1671 static int cnn = icvRegisterCNNStatModelType(); 1672 1673 #endif 1674 1675 // End of file 1676
