virtual void Classify(IDataSet* data) const { vector< vector<double> > features = PreprocessFeatures(data); svm_problem_xx test_prob(features, vector<int>(data->GetObjectCount(), 0)); for (int i = 0; i < data->GetObjectCount(); i++) data->SetTarget(i, svm_predict(model->model, test_prob.x[i])); }
int DenseSegmentation::ProcessFrame( bool flush, const std::vector<cv::Mat>* features, const cv::Mat* flow, // optional. std::vector<std::unique_ptr<SegmentationDesc>>* results) { if (seg_ == nullptr) { SegmentationOptions seg_options; GetSegmentationOptions(&seg_options); seg_.reset(new Segmentation(seg_options, frame_width_, frame_height_, chunk_id_)); seg_->InitializeOverSegmentation(*this, options_.chunk_size); } LOG(INFO) << "Processing frame " << input_frames_; if (features) { // Parallel construction of the graph, buffer features and flow. vector<cv::Mat> processed_features(features->size()); PreprocessFeatures(*features, &processed_features); feature_buffer_.push_back(processed_features); if (flow) { if (input_frames_ == 0) { DCHECK(flow->empty()) << "First frame's flow should be empty cv::Mat"; flow_buffer_.push_back(cv::Mat()); } else { DCHECK_EQ(frame_height_, flow->rows); DCHECK_EQ(frame_width_, flow->cols); cv::Mat flow_copy(flow->rows, flow->cols, CV_32FC2); // Deep copy, as we need to keep the memory around during parallel graph // construction. flow->copyTo(flow_copy); flow_buffer_.push_back(flow_copy); CHECK_EQ(flow_buffer_.size(), feature_buffer_.size()) << "Flow always has to be passed or be absent."; } } AddFrameToSegmentationFromFeatures(feature_buffer_.back(), nullptr); if (feature_buffer_.size() > 1) { // Connect temporally. ConnectSegmentationTemporallyFromFeatures( feature_buffer_.end()[-1], feature_buffer_.end()[-2], flow_buffer_.empty() ? nullptr : &flow_buffer_.back()); } ++input_frames_; } if (flush || feature_buffer_.size() - curr_chunk_start_ >= options_.chunk_size) { ChunkBoundaryOutput(flush, results); return results->size(); } return 0; }
virtual void Learn(IDataSet* data) { vector< vector<double> > features = PreprocessFeatures(data); vector<int> targets; for (int i = 0; i < data->GetObjectCount(); i++) targets.push_back(data->GetTarget(i)); train_prob = sh_ptr<svm_problem_xx>(new svm_problem_xx(features, targets)); double c_values[] = { 2048, 32768 }; double gamma_values[] = { 3.0517578125e-05, 0.0001220703125 }; svm_parameter best_param; double best_accuracy = -1; // select hyperparameters (regularization coefficient C and kernel parameter gamma) by 10-fold crossvalidation for (int c_index = 0; c_index < ARRAY_SIZE(c_values); c_index++) { for (int gamma_index = 0; gamma_index < ARRAY_SIZE(gamma_values); gamma_index++) { svm_parameter param; memset(¶m, 0, sizeof(param)); param.svm_type = C_SVC; param.kernel_type = RBF; param.C = c_values[c_index]; param.gamma = gamma_values[gamma_index]; param.cache_size = 100; param.eps = 1e-3; param.shrinking = 1; vector<double> res(targets.size()); svm_cross_validation(train_prob.get(), ¶m, 10, &res[0]); double accuracy = 0; for (int i = 0; i < res.size(); i++) if (res[i] == targets[i]) accuracy += 1; accuracy /= res.size(); if (accuracy > best_accuracy) { best_accuracy = accuracy; best_param = param; } } } model = sh_ptr<svm_model_xx>(new svm_model_xx(svm_train(train_prob.get(), &best_param))); }