bool NeuralDetector::Train(std::vector<Image_t> images) { size_t images_count = images.size(); cv::Mat trainData(images_count, ROWS * COLS, CV_32FC1); cv::Mat trainOutput(images_count, 1, CV_32FC1); for (size_t i = 0; i < images_count; ++i) { (images[i].image.reshape(0, 1)).copyTo(trainData.row(i)); if (images[i].info == SI_UNDEF) { return false; } trainOutput.at<float>(i, 0) = (images[i].info == SI_EXBNZ ? 1 : -1); } machineBrain.train( trainData, trainOutput, cv::Mat(), cv::Mat(), CvANN_MLP_TrainParams( cvTermCriteria( CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, MAX_ITER, MLP_EPSILON ), CvANN_MLP_TrainParams::BACKPROP, PARAM1, PARAM2 ) ); machineBrain.save("savednet.txt"); std::cout << "Saved\n"; return true; }
/** * Train the Image */ void NN::train(){ cout << Matrix->width << " - " << Matrix->height << "-"<< Length<< "-" << Labels->height << endl; int layer_sz[] = { Matrix->cols, int(Matrix->cols/4), Length }; CvMat layer_sizes = cvMat( 1, (int)(sizeof(layer_sz)/sizeof(layer_sz[0])), CV_32S, layer_sz ); NNModel.create( &layer_sizes, CvANN_MLP::SIGMOID_SYM ); NNModel.train( Matrix, Labels, 0, 0, CvANN_MLP_TrainParams(cvTermCriteria(CV_TERMCRIT_ITER,10000,0.001), CvANN_MLP_TrainParams::RPROP,0.01)); cout << Length << endl; save("NNModel"); }
std::string TrainProcessor::processInput(const std::string &input) { cv::Mat samples, categories; if (!fillSamples(input, samples, categories)) { return "Unable to load samples from file"; } const int inputSize = myCvPCA.eigenvalues.rows; const int outputSize = myClassesList.length(); cv::Mat inputs; myCvPCA.project(samples, inputs); cv::Mat outputs(samples.rows, outputSize, CV_32FC1); outputs = 0.0f; for (int i = 0; i < categories.rows; ++i) { char cat = categories.at<unsigned char>(i, 0); int index = (int) myClassesList.find(cat); outputs.at<float>(i, index) = 1.0f; } int layers = (myLayersCount > 0) ? myLayersCount : std::max(3, (int)(inputSize * myLayersScale)); std::cout << std::endl; std::cout << "Layers number = " << layers << std::endl; cv::Mat layerSizes(1, layers, CV_32SC1); --layers; std::cout << "Layer sizes: " << inputSize; layerSizes.at<int>(0, 0) = inputSize; for (int i = 1; i < layers; ++i) { const float scale = myLayersSizeScale + (1.0f - myLayersSizeScale) * (i-1) / (layers-1); const int sz = (int)(scale * (inputSize + (outputSize - inputSize) * i / layers)); std::cout << " " << sz; layerSizes.at<int>(0, i) = sz; } std::cout << " " << outputSize << std::endl; layerSizes.at<int>(0, layers) = outputSize; std::cout << std::endl; double timer = (double)cv::getTickCount(); myCvMLP.create(layerSizes, CvANN_MLP::SIGMOID_SYM, 1.0, 1.0); myCvMLP.train(inputs, outputs, cv::Mat(), cv::Mat(), CvANN_MLP_TrainParams(), 0); timer = (double)cv::getTickCount() - timer; std::cout << "Training time = " << (timer / cv::getTickFrequency()) << " s" << std::endl; std::cout << std::endl; return ""; }
//============================================================================== void ANN::train(Mat_<float> &trainData, vector<uchar> &labels, int numClasses) { cout << "ANN training..." << endl; attributesPerSample = trainData.cols; numberOfClasses = numClasses; int numberOfSamples = trainData.rows; Mat layers = Mat(1, 3, CV_32SC1); layers.at<int>(0,0) = attributesPerSample; // input layers.at<int>(0,1) = 2; // hidden layers.at<int>(0,2) = numberOfClasses; // output // Create the network using a sigmoid function //-------------------------------------------------------------------------- nnetwork = new CvANN_MLP(); nnetwork->create(layers, CvANN_MLP::SIGMOID_SYM, 1.0, 1.0); // Prepare labels in required format //-------------------------------------------------------------------------- Mat_<float> trainLabels = Mat_<uchar>::zeros(numberOfSamples, numberOfClasses); // Fill in the matrix with labels for(int i = 0; i < numberOfSamples; i++) { trainLabels(i, labels[i]) = 1.0; } // Set the training parameters //-------------------------------------------------------------------------- CvANN_MLP_TrainParams params = CvANN_MLP_TrainParams( // Terminate the training after either 1000 iterations or a very small // change in the network weights below the specified value cvTermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 10, 0.001), // Use back-propagation for training CvANN_MLP_TrainParams::BACKPROP, // Coefficients for back-propagation training 0.1, 0.1 ); // Train the neural network //-------------------------------------------------------------------------- int iters = nnetwork->train(trainData, trainLabels, Mat(), Mat(), params); cout << "Number of iterations: " << iters << endl; }
void ANN::parametricTrain(cv::Mat_<float> &trainData, std::vector<uchar> &labels, int iter, vector<int> & nodes, int hidden){ // Prepare labels in required format //-------------------------------------------------------------------------- Mat_<float> trainLabels = Mat_<uchar>::zeros(trainData.rows, this->numberOfClasses); // Fill in the matrix with labels for(int i = 0; i < trainData.rows; i++) { trainLabels(i, labels[i]) = 1.0; } //cout << trainLabels << endl; // Set the training parameters //-------------------------------------------------------------------------- CvANN_MLP_TrainParams params = CvANN_MLP_TrainParams( // Terminate the training after either 1000 iterations or a very small // change in the network weights below the specified value cvTermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, iter, 0.00000001), // Use back-propagation for training CvANN_MLP_TrainParams::BACKPROP, // Coefficients for back-propagation training 0.1, 0.1 ); // Train the neural network //-------------------------------------------------------------------------- int iters = nnetwork->train(trainData, trainLabels, Mat(), Mat(), params); #if INFO cout << "Number of iterations: " << iters << endl; #endif stringstream ss; ss << iters << "_" << hidden << "_Classes_"; for(int i = 0; i < nodes.size(); i++){ ss << nodes[i] << "_"; } ss <<"nodes"; string name = ss.str(); name="iter_"+name; //this->saveTofile((char*)name.c_str()); }
static int build_mlp_classifier( char* data_filename, char* filename_to_save, char* filename_to_load ) { const int class_count = 26; CvMat* data = 0; CvMat train_data; CvMat* responses = 0; CvMat* mlp_response = 0; int ok = read_num_class_data( data_filename, 16, &data, &responses ); int nsamples_all = 0, ntrain_samples = 0; int i, j; double train_hr = 0, test_hr = 0; CvANN_MLP mlp; if( !ok ) { printf( "Could not read the database %s\n", data_filename ); return -1; } printf( "The database %s is loaded.\n", data_filename ); nsamples_all = data->rows; ntrain_samples = (int)(nsamples_all*0.8); // Create or load MLP classifier if( filename_to_load ) { // load classifier from the specified file mlp.load( filename_to_load ); ntrain_samples = 0; if( !mlp.get_layer_count() ) { printf( "Could not read the classifier %s\n", filename_to_load ); return -1; } printf( "The classifier %s is loaded.\n", data_filename ); } else { // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // // MLP does not support categorical variables by explicitly. // So, instead of the output class label, we will use // a binary vector of <class_count> components for training and, // therefore, MLP will give us a vector of "probabilities" at the // prediction stage // // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CvMat* new_responses = cvCreateMat( ntrain_samples, class_count, CV_32F ); // 1. unroll the responses printf( "Unrolling the responses...\n"); for( i = 0; i < ntrain_samples; i++ ) { int cls_label = cvRound(responses->data.fl[i]) - 'A'; float* bit_vec = (float*)(new_responses->data.ptr + i*new_responses->step); for( j = 0; j < class_count; j++ ) bit_vec[j] = 0.f; bit_vec[cls_label] = 1.f; } cvGetRows( data, &train_data, 0, ntrain_samples ); // 2. train classifier int layer_sz[] = { data->cols, 100, 100, class_count }; CvMat layer_sizes = cvMat( 1, (int)(sizeof(layer_sz)/sizeof(layer_sz[0])), CV_32S, layer_sz ); mlp.create( &layer_sizes ); printf( "Training the classifier (may take a few minutes)...\n"); mlp.train( &train_data, new_responses, 0, 0, CvANN_MLP_TrainParams(cvTermCriteria(CV_TERMCRIT_ITER,300,0.01), #if 1 CvANN_MLP_TrainParams::BACKPROP,0.001)); #else CvANN_MLP_TrainParams::RPROP,0.05)); #endif cvReleaseMat( &new_responses ); printf("\n"); } mlp_response = cvCreateMat( 1, class_count, CV_32F ); // compute prediction error on train and test data for( i = 0; i < nsamples_all; i++ ) { int best_class; CvMat sample; cvGetRow( data, &sample, i ); CvPoint max_loc = {0,0}; mlp.predict( &sample, mlp_response ); cvMinMaxLoc( mlp_response, 0, 0, 0, &max_loc, 0 ); best_class = max_loc.x + 'A'; int r = fabs((double)best_class - responses->data.fl[i]) < FLT_EPSILON ? 1 : 0; if( i < ntrain_samples ) train_hr += r; else test_hr += r; } test_hr /= (double)(nsamples_all-ntrain_samples); train_hr /= (double)ntrain_samples; printf( "Recognition rate: train = %.1f%%, test = %.1f%%\n", train_hr*100., test_hr*100. ); // Save classifier to file if needed if( filename_to_save ) mlp.save( filename_to_save ); cvReleaseMat( &mlp_response ); cvReleaseMat( &data ); cvReleaseMat( &responses ); return 0; }
//--------------------------------------------------------- bool COpenCV_NNet::On_Execute(void) { //------------------------------------------------- bool b_updateWeights, b_noInputScale, b_noOutputScale, b_NoData; int i_matType, i_layers, i_maxIter, i_neurons, i_areasClassId, i_trainFeatTotalCount, *i_outputFeatureIdxs, i_outputFeatureCount, i_Grid, x, y, i_evalOut, i_winner; double d_alpha, d_beta, d_eps; DATA_TYPE e_dataType; TRAINING_METHOD e_trainMet; ACTIVATION_FUNCTION e_actFunc; CSG_Table *t_Weights, *t_Indices, *t_TrainInput, *t_EvalInput, *t_EvalOutput; CSG_Parameter_Grid_List *gl_TrainInputs; CSG_Grid *g_EvalOutput, *g_EvalOutputCert; CSG_Shapes *s_TrainInputAreas; CSG_Parameters *p_TrainFeatures; TSG_Point p; CvMat *mat_Weights, *mat_Indices, **mat_data, *mat_neuralLayers, mat_layerSizesSub, *mat_EvalInput, *mat_EvalOutput; // todo: mat_indices to respect input indices, mat_weights for initialization CvANN_MLP_TrainParams tp_trainParams; CvANN_MLP model; b_updateWeights = Parameters("UPDATE_WEIGHTS" )->asBool(); b_noInputScale = Parameters("NO_INPUT_SCALE" )->asBool(); b_noOutputScale = Parameters("NO_OUTPUT_SCALE" )->asBool(); i_layers = Parameters("NNET_LAYER" )->asInt(); i_neurons = Parameters("NNET_NEURONS" )->asInt(); i_maxIter = Parameters("MAX_ITER" )->asInt(); i_areasClassId = Parameters("TRAIN_INPUT_AREAS_CLASS_FIELD" )->asInt(); e_dataType = (DATA_TYPE)Parameters("DATA_TYPE" )->asInt(); e_trainMet = (TRAINING_METHOD)Parameters("TRAINING_METHOD" )->asInt(); e_actFunc = (ACTIVATION_FUNCTION)Parameters("ACTIVATION_FUNCTION" )->asInt(); d_alpha = Parameters("ALPHA" )->asDouble(); d_beta = Parameters("BETA" )->asDouble(); d_eps = Parameters("EPSILON" )->asDouble(); t_Weights = Parameters("WEIGHTS" )->asTable(); t_Indices = Parameters("INDICES" )->asTable(); t_TrainInput = Parameters("TRAIN_INPUT_TABLE" )->asTable(); t_EvalInput = Parameters("EVAL_INPUT_TABLE" )->asTable(); t_EvalOutput = Parameters("EVAL_OUTPUT_TABLE" )->asTable(); p_TrainFeatures = Parameters("TRAIN_FEATURES_TABLE" )->asParameters(); gl_TrainInputs = Parameters("TRAIN_INPUT_GRIDS" )->asGridList(); g_EvalOutput = Parameters("EVAL_OUTPUT_GRID_CLASSES" )->asGrid(); g_EvalOutputCert = Parameters("EVAL_OUTPUT_GRID_CERTAINTY" )->asGrid(); s_TrainInputAreas = Parameters("TRAIN_INPUT_AREAS" )->asShapes(); // Fixed matrix type (TODO: Analyze what to do for other types of data (i.e. images)) i_matType = CV_32FC1; //------------------------------------------------- if (e_dataType == TABLE) { // We are working with TABLE data if( t_TrainInput->Get_Count() == 0 || p_TrainFeatures->Get_Count() == 0 ) { Error_Set(_TL("Select an input table and at least one output feature!")); return( false ); } // Count the total number of available features i_trainFeatTotalCount = t_TrainInput->Get_Field_Count(); // Count the number of selected output features i_outputFeatureIdxs = (int *)SG_Calloc(i_trainFeatTotalCount, sizeof(int)); i_outputFeatureCount = 0; for(int i=0; i<p_TrainFeatures->Get_Count(); i++) { if( p_TrainFeatures->Get_Parameter(i)->asBool() ) { i_outputFeatureIdxs[i_outputFeatureCount++] = CSG_String(p_TrainFeatures->Get_Parameter(i)->Get_Identifier()).asInt(); } } // Update the number of training features i_trainFeatTotalCount = i_trainFeatTotalCount-i_outputFeatureCount; if( i_outputFeatureCount <= 0 ) { Error_Set(_TL("Select at least one output feature!")); return( false ); } // Now convert the input and output training data into a OpenCV matrix objects mat_data = GetTrainAndOutputMatrix(t_TrainInput, i_matType, i_outputFeatureIdxs, i_outputFeatureCount); } else { // TODO: Add some grid validation logic i_trainFeatTotalCount = gl_TrainInputs->Get_Count(); i_outputFeatureCount = s_TrainInputAreas->Get_Count(); // Convert the data from the grid into the matrix from mat_data = GetTrainAndOutputMatrix(gl_TrainInputs, i_matType, s_TrainInputAreas, i_areasClassId, g_EvalOutput, g_EvalOutputCert); } //------------------------------------------------- // Add two additional layer to the network topology (0-th layer for input and the last as the output) i_layers = i_layers + 2; mat_neuralLayers = cvCreateMat(i_layers, 1, CV_32SC1); cvGetRows(mat_neuralLayers, &mat_layerSizesSub, 0, i_layers); //Setting the number of neurons on each layer for (int i = 0; i < i_layers; i++) { if (i == 0) { // The first layer needs the same size (number of nerons) as the number of columns in the training data cvSet1D(&mat_layerSizesSub, i, cvScalar(i_trainFeatTotalCount)); } else if (i == i_layers-1) { // The last layer needs the same size (number of neurons) as the number of output columns cvSet1D(&mat_layerSizesSub, i, cvScalar(i_outputFeatureCount)); } else { // On every other layer set the layer size selected by the user cvSet1D(&mat_layerSizesSub, i, cvScalar(i_neurons)); } } //------------------------------------------------- // Create the training params object tp_trainParams = CvANN_MLP_TrainParams(); tp_trainParams.term_crit = cvTermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, i_maxIter, d_eps); // Check which training method was selected and set corresponding params if(e_trainMet == RPROP) { // Set all RPROP specific params tp_trainParams.train_method = CvANN_MLP_TrainParams::RPROP; tp_trainParams.rp_dw0 = Parameters("RP_DW0" )->asDouble(); tp_trainParams.rp_dw_plus = Parameters("RP_DW_PLUS" )->asDouble(); tp_trainParams.rp_dw_minus = Parameters("RP_DW_MINUS" )->asDouble(); tp_trainParams.rp_dw_min = Parameters("RP_DW_MIN" )->asDouble(); tp_trainParams.rp_dw_max = Parameters("RP_DW_MAX" )->asDouble(); } else { // Set all BPROP specific params tp_trainParams.train_method = CvANN_MLP_TrainParams::BACKPROP; tp_trainParams.bp_dw_scale = Parameters("BP_DW_SCALE" )->asDouble(); tp_trainParams.bp_moment_scale = Parameters("BP_MOMENT_SCALE" )->asInt(); } //------------------------------------------------- // Create the model (depending on the activation function) if(e_actFunc == SIGMOID) { model.create(mat_neuralLayers); } else { model.create(mat_neuralLayers, CvANN_MLP::GAUSSIAN, d_alpha, d_beta); } //------------------------------------------------- // Now train the network // TODO: Integrate init weights and indicies for record selection // mat_Weights = GetMatrix(t_Weights, i_matType); // mat_Indices = GetMatrix(t_Indices, i_matType); //model.train(mat_TrainInput, mat_TrainOutput, NULL, NULL, tp_trainParams); model.train(mat_data[0], mat_data[1], NULL, NULL, tp_trainParams); //------------------------------------------------- // Predict data if (e_dataType == TABLE) { // Get the eavaluation/test matrix from the eval table mat_EvalInput = GetEvalMatrix(t_EvalInput, i_matType); } else { // Train and eval data overlap in grid mode mat_EvalInput = GetEvalMatrix(gl_TrainInputs, i_matType); } // Prepare output matrix mat_EvalOutput = cvCreateMat(mat_EvalInput->rows, i_outputFeatureCount, i_matType); // Start prediction model.predict(mat_EvalInput, mat_EvalOutput); Message_Add(_TL("Successfully trained the network and predicted the values. Here comes the output.")); //------------------------------------------------- // Save and print results if (e_dataType == TABLE) { // DEBUG -> Save results to output table and print results for (int i = 0; i < i_outputFeatureCount; i++) { t_EvalOutput->Add_Field(CSG_String(t_TrainInput->Get_Field_Name(i_outputFeatureIdxs[i])), SG_DATATYPE_Float); } for (int i = 0; i < mat_EvalOutput->rows; i++) { CSG_Table_Record* tr_record = t_EvalOutput->Add_Record(); for (int j = 0; j < i_outputFeatureCount; j++) { float f_targetValue = mat_EvalOutput->data.fl[i*i_outputFeatureCount+j]; tr_record->Set_Value(j, f_targetValue); } } } else { // Fill the output table output for (int i = 0; i < i_outputFeatureCount; i++) { // TODO: Get the class name t_EvalOutput->Add_Field(CSG_String::Format(SG_T("CLASS_%d"), i), SG_DATATYPE_Float); } for (int i = 0; i < mat_EvalOutput->rows; i++) { CSG_Table_Record* tr_record = t_EvalOutput->Add_Record(); for (int j = 0; j < i_outputFeatureCount; j++) { float f_targetValue = mat_EvalOutput->data.fl[i*i_outputFeatureCount+j]; tr_record->Set_Value(j, f_targetValue); } } i_evalOut = 0; // Fill the output grid for(y=0, p.y=Get_YMin(); y<Get_NY() && Set_Progress(y); y++, p.y+=Get_Cellsize()) { for(x=0, p.x=Get_XMin(); x<Get_NX(); x++, p.x+=Get_Cellsize()) { for(i_Grid=0, b_NoData=false; i_Grid<gl_TrainInputs->Get_Count() && !b_NoData; i_Grid++) { // If there is one grid that has no data in this point p, then set the no data flag if( gl_TrainInputs->asGrid(i_Grid)->is_NoData(x, y) ) { b_NoData = true; } } if (!b_NoData) { // We have data in all grids, so this is a point that was predicted // Get the winner class for this point and set it to the output grid float f_targetValue = 0; for (int j = 0; j < i_outputFeatureCount; j++) { if (mat_EvalOutput->data.fl[i_evalOut*i_outputFeatureCount+j] > f_targetValue) { // The current value is higher than the last one, so lets memorize the current class f_targetValue = mat_EvalOutput->data.fl[i_evalOut*i_outputFeatureCount+j]; i_winner = j; } } // Now finally set the values to the grids g_EvalOutput->Set_Value(x, y, i_winner); g_EvalOutputCert->Set_Value(x, y, f_targetValue); i_evalOut++; } } } } return( true ); }
// Read the training data and train the network. void trainMachine() { int i; //The number of training samples. int train_sample_count = 130; //The training data matrix. float td[130][61]; //Read the training file FILE *fin; fin = fopen("data/sonar_train.csv", "r"); //Create the matrices //Input data samples. Matrix of order (train_sample_count x 60) CvMat* trainData = cvCreateMat(train_sample_count, 60, CV_32FC1); //Output data samples. Matrix of order (train_sample_count x 1) CvMat* trainClasses = cvCreateMat(train_sample_count, 1, CV_32FC1); //The weight of each training data sample. We'll later set all to equal weights. CvMat* sampleWts = cvCreateMat(train_sample_count, 1, CV_32FC1); //The matrix representation of our ANN. We'll have four layers. CvMat* neuralLayers = cvCreateMat(4, 1, CV_32SC1); //Setting the number of neurons on each layer of the ANN /* We have in Layer 1: 60 neurons (60 inputs) Layer 2: 150 neurons (hidden layer) Layer 3: 225 neurons (hidden layer) Layer 4: 1 neurons (1 output) */ cvSet1D(neuralLayers, 0, cvScalar(60)); cvSet1D(neuralLayers, 1, cvScalar(150)); cvSet1D(neuralLayers, 2, cvScalar(225)); cvSet1D(neuralLayers, 3, cvScalar(1)); //Read and populate the samples. for (i=0;i<train_sample_count;i++) fscanf(fin,"%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f", &td[i][0],&td[i][1],&td[i][2],&td[i][3],&td[i][4],&td[i][5],&td[i][6],&td[i][7],&td[i][8],&td[i][9],&td[i][10],&td[i][11],&td[i][12],&td[i][13],&td[i][14],&td[i][15],&td[i][16],&td[i][17],&td[i][18],&td[i][19],&td[i][20],&td[i][21],&td[i][22],&td[i][23],&td[i][24],&td[i][25],&td[i][26],&td[i][27],&td[i][28],&td[i][29],&td[i][30],&td[i][31],&td[i][32],&td[i][33],&td[i][34],&td[i][35],&td[i][36],&td[i][37],&td[i][38],&td[i][39],&td[i][40],&td[i][41],&td[i][42],&td[i][43],&td[i][44],&td[i][45],&td[i][46],&td[i][47],&td[i][48],&td[i][49],&td[i][50],&td[i][51],&td[i][52],&td[i][53],&td[i][54],&td[i][55],&td[i][56],&td[i][57],&td[i][58],&td[i][59],&td[i][60]); //we are done reading the file, so close it fclose(fin); //Assemble the ML training data. for (i=0; i<train_sample_count; i++) { //inputs for (int j = 0; j < 60; j++) cvSetReal2D(trainData, i, j, td[i][j]); //Output cvSet1D(trainClasses, i, cvScalar(td[i][60])); //Weight (setting everything to 1) cvSet1D(sampleWts, i, cvScalar(1)); } //Create our ANN. ann.create(neuralLayers); cout << "training...\n"; //Train it with our data. ann.train( trainData, trainClasses, sampleWts, 0, CvANN_MLP_TrainParams( cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 100000, 0.000001), CvANN_MLP_TrainParams::BACKPROP, 0.01, 0.05)); }
// Read the training data and train the network. void trainMachine() { int i; //The number of training samples. int train_sample_count; //The training data matrix. //Note that we are limiting the number of training data samples to 1000 here. //The data sample consists of two inputs and an output. That's why 3. float td[10000][3]; //Read the training file /* A sample file contents(say we are training the network for generating the mean given two numbers) would be: 5 12 16 14 10 5 7.5 8 10 9 5 4 4.5 12 6 9 */ FILE *fin; fin = fopen("train.txt", "r"); //Get the number of samples. fscanf(fin, "%d", &train_sample_count); printf("Found training file with %d samples...\n", train_sample_count); //Create the matrices //Input data samples. Matrix of order (train_sample_count x 2) CvMat* trainData = cvCreateMat(train_sample_count, 2, CV_32FC1); //Output data samples. Matrix of order (train_sample_count x 1) CvMat* trainClasses = cvCreateMat(train_sample_count, 1, CV_32FC1); //The weight of each training data sample. We'll later set all to equal weights. CvMat* sampleWts = cvCreateMat(train_sample_count, 1, CV_32FC1); //The matrix representation of our ANN. We'll have four layers. CvMat* neuralLayers = cvCreateMat(4, 1, CV_32SC1); CvMat trainData1, trainClasses1, neuralLayers1, sampleWts1; cvGetRows(trainData, &trainData1, 0, train_sample_count); cvGetRows(trainClasses, &trainClasses1, 0, train_sample_count); cvGetRows(trainClasses, &trainClasses1, 0, train_sample_count); cvGetRows(sampleWts, &sampleWts1, 0, train_sample_count); cvGetRows(neuralLayers, &neuralLayers1, 0, 4); //Setting the number of neurons on each layer of the ANN /* We have in Layer 1: 2 neurons (2 inputs) Layer 2: 3 neurons (hidden layer) Layer 3: 3 neurons (hidden layer) Layer 4: 1 neurons (1 output) */ cvSet1D(&neuralLayers1, 0, cvScalar(2)); cvSet1D(&neuralLayers1, 1, cvScalar(3)); cvSet1D(&neuralLayers1, 2, cvScalar(3)); cvSet1D(&neuralLayers1, 3, cvScalar(1)); //Read and populate the samples. for (i=0;i<train_sample_count;i++) fscanf(fin,"%f %f %f",&td[i][0],&td[i][1],&td[i][2]); fclose(fin); //Assemble the ML training data. for (i=0; i<train_sample_count; i++) { //Input 1 cvSetReal2D(&trainData1, i, 0, td[i][0]); //Input 2 cvSetReal2D(&trainData1, i, 1, td[i][1]); //Output cvSet1D(&trainClasses1, i, cvScalar(td[i][2])); //Weight (setting everything to 1) cvSet1D(&sampleWts1, i, cvScalar(1)); } //Create our ANN. machineBrain.create(neuralLayers);//sigmoid 0 0(激活函数的两个参数) //Train it with our data. machineBrain.train( trainData,//输入 trainClasses,//输出 sampleWts,//输入项的权值 0, CvANN_MLP_TrainParams( cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,///类型 CV_TERMCRIT_ITER 和CV_TERMCRIT_EPS二值之一,或者二者的组合 10000000,//最大迭代次数 0.00000001//结果的精确性 两次迭代间权值变化量 ), CvANN_MLP_TrainParams::BACKPROP,//BP算法 0.01,//几个可显式调整的参数 学习速率 阿尔法 0.05 //惯性参数 ) ); }
void CvANN_MLP::read_params( CvFileStorage* fs, CvFileNode* node ) { //CV_FUNCNAME( "CvANN_MLP::read_params" ); __BEGIN__; const char* activ_func_name = cvReadStringByName( fs, node, "activation_function", 0 ); CvFileNode* tparams_node; if( activ_func_name ) activ_func = strcmp( activ_func_name, "SIGMOID_SYM" ) == 0 ? SIGMOID_SYM : strcmp( activ_func_name, "IDENTITY" ) == 0 ? IDENTITY : strcmp( activ_func_name, "GAUSSIAN" ) == 0 ? GAUSSIAN : 0; else activ_func = cvReadIntByName( fs, node, "activation_function" ); f_param1 = cvReadRealByName( fs, node, "f_param1", 0 ); f_param2 = cvReadRealByName( fs, node, "f_param2", 0 ); set_activ_func( activ_func, f_param1, f_param2 ); min_val = cvReadRealByName( fs, node, "min_val", 0. ); max_val = cvReadRealByName( fs, node, "max_val", 1. ); min_val1 = cvReadRealByName( fs, node, "min_val1", 0. ); max_val1 = cvReadRealByName( fs, node, "max_val1", 1. ); tparams_node = cvGetFileNodeByName( fs, node, "training_params" ); params = CvANN_MLP_TrainParams(); if( tparams_node ) { const char* tmethod_name = cvReadStringByName( fs, tparams_node, "train_method", "" ); CvFileNode* tcrit_node; if( strcmp( tmethod_name, "BACKPROP" ) == 0 ) { params.train_method = CvANN_MLP_TrainParams::BACKPROP; params.bp_dw_scale = cvReadRealByName( fs, tparams_node, "dw_scale", 0 ); params.bp_moment_scale = cvReadRealByName( fs, tparams_node, "moment_scale", 0 ); } else if( strcmp( tmethod_name, "RPROP" ) == 0 ) { params.train_method = CvANN_MLP_TrainParams::RPROP; params.rp_dw0 = cvReadRealByName( fs, tparams_node, "dw0", 0 ); params.rp_dw_plus = cvReadRealByName( fs, tparams_node, "dw_plus", 0 ); params.rp_dw_minus = cvReadRealByName( fs, tparams_node, "dw_minus", 0 ); params.rp_dw_min = cvReadRealByName( fs, tparams_node, "dw_min", 0 ); params.rp_dw_max = cvReadRealByName( fs, tparams_node, "dw_max", 0 ); } tcrit_node = cvGetFileNodeByName( fs, tparams_node, "term_criteria" ); if( tcrit_node ) { params.term_crit.epsilon = cvReadRealByName( fs, tcrit_node, "epsilon", -1 ); params.term_crit.max_iter = cvReadIntByName( fs, tcrit_node, "iterations", -1 ); params.term_crit.type = (params.term_crit.epsilon >= 0 ? CV_TERMCRIT_EPS : 0) + (params.term_crit.max_iter >= 0 ? CV_TERMCRIT_ITER : 0); } } __END__; }
// Read the training data and train the network. void trainMachine() { int i; //The number of training samples. int train_sample_count; //The training data matrix. //Note that we are limiting the number of training data samples to 1000 here. //The data sample consists of two inputs and an output. That's why 3. //td es la matriz dinde se cargan las muestras float td[3000][7]; //Read the training file /* A sample file contents(say we are training the network for generating the mean given two numbers) would be: 5 12 16 14 10 5 7.5 8 10 9 5 4 4.5 12 6 9 */ FILE *fin; fin = fopen("train.txt", "r"); //Get the number of samples. fscanf(fin, "%d", &train_sample_count); printf("Found training file with %d samples...\n", train_sample_count); //Create the matrices //Input data samples. Matrix of order (train_sample_count x 2) CvMat* trainData = cvCreateMat(train_sample_count, 6, CV_32FC1); //Output data samples. Matrix of order (train_sample_count x 1) CvMat* trainClasses = cvCreateMat(train_sample_count, 1, CV_32FC1); //The weight of each training data sample. We'll later set all to equal weights. CvMat* sampleWts = cvCreateMat(train_sample_count, 1, CV_32FC1); //The matrix representation of our ANN. We'll have four layers. CvMat* neuralLayers = cvCreateMat(2, 1, CV_32SC1); CvMat trainData1, trainClasses1, neuralLayers1, sampleWts1; cvGetRows(trainData, &trainData1, 0, train_sample_count); cvGetRows(trainClasses, &trainClasses1, 0, train_sample_count); cvGetRows(trainClasses, &trainClasses1, 0, train_sample_count); cvGetRows(sampleWts, &sampleWts1, 0, train_sample_count); cvGetRows(neuralLayers, &neuralLayers1, 0, 2); //Setting the number of neurons on each layer of the ANN /* We have in Layer 1: 2 neurons (6 inputs) Layer 2: 3 neurons (hidden layer) Layer 3: 3 neurons (hidden layer) Layer 4: 1 neurons (1 output) */ cvSet1D(&neuralLayers1, 0, cvScalar(6)); //cvSet1D(&neuralLayers1, 1, cvScalar(3)); //cvSet1D(&neuralLayers1, 2, cvScalar(3)); cvSet1D(&neuralLayers1, 1, cvScalar(1)); //Read and populate the samples. for (i=0; i<train_sample_count; i++) fscanf(fin,"%f %f %f %f",&td[i][0],&td[i][1],&td[i][2],&td[i][3]); fclose(fin); //Assemble the ML training data. for (i=0; i<train_sample_count; i++) { //Input 1 cvSetReal2D(&trainData1, i, 0, td[i][0]); //Input 2 cvSetReal2D(&trainData1, i, 1, td[i][1]); cvSetReal2D(&trainData1, i, 2, td[i][2]); cvSetReal2D(&trainData1, i, 3, td[i][3]); cvSetReal2D(&trainData1, i, 4, td[i][4]); cvSetReal2D(&trainData1, i, 5, td[i][5]); //Output cvSet1D(&trainClasses1, i, cvScalar(td[i][6])); //Weight (setting everything to 1) cvSet1D(&sampleWts1, i, cvScalar(1)); } //Create our ANN. machineBrain.create(neuralLayers); //Train it with our data. //See the Machine learning reference at http://www.seas.upenn.edu/~bensapp/opencvdocs/ref/opencvref_ml.htm#ch_ann machineBrain.train( trainData, trainClasses, sampleWts, 0, CvANN_MLP_TrainParams( cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 100000, 1.0 ), CvANN_MLP_TrainParams::BACKPROP, 0.01, 0.05 ) ); }