static std::vector<Point2d> drawKeypoints(Blob<Dtype>* blob,int nIter,Mat&vis,Scalar color) { // check geometry CHECK_LE(nIter-1,blob->num()); CHECK_EQ(blob->channels(),2*jvl::active_keypoints.size()); CHECK_EQ(blob->height(),1); CHECK_EQ(blob->width(),1); const Dtype* label_data = blob->cpu_data() + blob->offset(nIter); Mat label_mat(2*jvl::active_keypoints.size(),1,DataType<Dtype>::type); caffe_copy(blob->channels()*blob->width()*blob->height(),label_data,label_mat.ptr<Dtype>()); std::vector<Point2d> points; for(int iter = 0; iter < 2*jvl::active_keypoints.size(); iter +=2 ) { Dtype u = sf*label_mat.at<Dtype>(iter); Dtype v = sf*label_mat.at<Dtype>(iter+1); cv::putText(vis,jvl::printfpp("%d",iter),Point2d(u,v),FONT_HERSHEY_SIMPLEX,.5,color); points.push_back(Point2d(u,v)); } return points; }
// Arguments "opt_param" and "grad" are updated by nlopt. // "opt_param" corresponds to the optimization parameters. // "grad" corresponds to the gradient. double NeuralNetwork::ComputeCost(const std::vector<double> &opt_param, std::vector<double> &grad,const DataMulti &data_multi) { assert(num_layers_ >= 2); const int kNumFeatures = hidden_layer_size_*(input_layer_size_+1)+\ output_layer_size_*(hidden_layer_size_+1); assert(kNumFeatures >= 1); const int kNumTrainEx = data_multi.num_train_ex(); assert(kNumTrainEx >= 1); arma::vec nlopt_theta = arma::randu<arma::vec>(kNumFeatures,1); // Uses current value of "theta" from nlopt. for(int feature_index=0; feature_index<kNumFeatures; feature_index++) { nlopt_theta(feature_index) = opt_param[feature_index]; } // Extracts Theta1 and Theta2 from nlopt_theta. const arma::vec kNLoptTheta1 = \ nlopt_theta.rows(0,hidden_layer_size_*(input_layer_size_+1)-1); const arma::vec kNLoptTheta2 = \ nlopt_theta.rows(hidden_layer_size_*(input_layer_size_+1),\ hidden_layer_size_*(input_layer_size_+1)+\ output_layer_size_*(hidden_layer_size_+1)-1); // Reshapes Theta1 and Theta2 as matrices. const arma::mat kNLoptTheta1Mat = \ arma::reshape(kNLoptTheta1,hidden_layer_size_,input_layer_size_+1); const arma::mat kNLoptTheta2Mat = \ arma::reshape(kNLoptTheta2,output_layer_size_,hidden_layer_size_+1); std::vector<arma::mat> current_theta; current_theta.push_back(kNLoptTheta1Mat); current_theta.push_back(kNLoptTheta2Mat); set_theta(current_theta); // Runs feedforward propagation. arma::mat layer_activation_in = data_multi.training_features(); arma::mat sigmoid_arg = layer_activation_in*theta_.at(0).t(); arma::mat layer_activation_out = ComputeSigmoid(sigmoid_arg); for(int layer_index=1; layer_index<num_layers_; layer_index++) { const arma::mat kOnesMat = arma::ones(layer_activation_out.n_rows,1); layer_activation_in = arma::join_horiz(kOnesMat,layer_activation_out); sigmoid_arg = layer_activation_in*theta_.at(layer_index).t(); layer_activation_out = ComputeSigmoid(sigmoid_arg); } // Sets up matrix of (multi-class) training labels. arma::mat label_mat = arma::randu<arma::mat>(kNumTrainEx,output_layer_size_); label_mat.zeros(kNumTrainEx,output_layer_size_); for(int example_index=0; example_index<kNumTrainEx; example_index++) { int col_index = \ (int)arma::as_scalar(data_multi.training_labels()(example_index)); label_mat(example_index,col_index-1) = 1.0; } // Computes regularized neural network cost. const arma::mat kCostFuncVal = \ (-1)*(label_mat%arma::log(layer_activation_out)+\ (1-label_mat)%arma::log(1-layer_activation_out)); const double kJTheta = accu(kCostFuncVal)/kNumTrainEx; const arma::mat kNLoptTheta1MatSquared = kNLoptTheta1Mat%kNLoptTheta1Mat; const arma::mat kNLoptTheta2MatSquared = kNLoptTheta2Mat%kNLoptTheta2Mat; const arma::mat kNLoptTheta1MatSquaredTrans = kNLoptTheta1MatSquared.t(); const arma::mat kNLoptTheta2MatSquaredTrans = kNLoptTheta2MatSquared.t(); const double kRegTerm = \ (lambda()/(2*kNumTrainEx))*(accu(kNLoptTheta1MatSquaredTrans)+\ accu(kNLoptTheta2MatSquaredTrans)-\ accu(kNLoptTheta1MatSquaredTrans.row(0))-\ accu(kNLoptTheta2MatSquaredTrans.row(0))); const double kJThetaReg = kJTheta+kRegTerm; // Updates "grad" for nlopt. const int kReturnCode = this->ComputeGradient(data_multi); const arma::vec kCurrentGradient = gradient(); for(int feature_index=0; feature_index<kNumFeatures; feature_index++) { grad[feature_index] = kCurrentGradient(feature_index); } printf("kJThetaReg = %.6f\n",kJThetaReg); return kJThetaReg; }