// TODO: move this constant to some other area or make it derived based on number of training std::vector<float>s
void StochasticGradientDescent::RunRef( const std::vector< std::vector<float> > &trainingData,
const std::vector<int> &trainingLabels,
const std::vector<std::vector<float>> &validationData,
const std::vector<int> &validationLabels,
unsigned int max_iterations,
SkyNetDiagnostic &diagnostic, SkynetTerminalInterface& exitter)
{
std::uniform_int_distribution< int > sample_index( 0, trainingData.size() -1 );
std::random_device rd;
int i=0;
bool finish = false;
//TODO: Store proper error
diagnostic.storeWeightsAndError(m_weights,0.0f,0.0f);
while((i<max_iterations)&&(finish == false)) {
auto ridx = sample_index(rd);
finish = updateWeights(trainingData[ridx],trainingLabels[ridx]);
//TODO: Store proper error
diagnostic.storeWeightsAndError(m_weights,0.0f, 0.0f);
// Check if user want to cease learning
finish = finish || exitter();
if(finish == false) {
++i;
} else {
// TODO: If flatness was reached then
// check if error is below certain error threshold
}
}
if(finish == false) {
printf("Warning: Stochastic Gradient Descent Learning alogorithm exhusted all iterations. TODO: Make proper termination criteria\n");
}
return;
}
cv::Mat ransac(const cv::Mat& samples, cv::TermCriteria termcrit, double thresh_outliar, double sampling_rate, double minimum_inliar_rate){
assert(0 < sampling_rate && sampling_rate <= 1);
assert(0 < minimum_inliar_rate && minimum_inliar_rate <= 1);
cv::Mat best_model(cv::Size(samples.cols,1),samples.type(),cv::Scalar(0));
size_t dim = samples.cols;
size_t sample_num = samples.rows;
size_t iterations = 0;
size_t sampling_num = sample_num * sampling_rate;
size_t minimum_inliar_num = sample_num * minimum_inliar_rate;
double best_error = DBL_MAX;
std::vector<size_t> sample_index(sample_num);
for(size_t i=0;i<sample_num;i++) sample_index[i] = i;
while( ( (termcrit.type & CV_TERMCRIT_ITER) == 0 || iterations < (size_t)termcrit.maxCount)
&& ( (termcrit.type & CV_TERMCRIT_EPS) == 0 || best_error > termcrit.epsilon) ){
// main loop
// random sampling (use first part as sampled data.)
std::random_shuffle(sample_index.begin(),sample_index.end());
std::vector<size_t> consensus_set(sampling_num);
std::copy(sample_index.begin(),sample_index.begin()+sampling_num,consensus_set.begin());
cv::Mat this_model = fitModel(samples,sample_index.begin(),sample_index.begin()+sampling_num);
// do process for not-sampled elements.
cv::Rect roi(0,0,dim,1);
for(size_t _i=sampling_num;_i<sample_num;_i++){
size_t idx = sample_index[_i];
roi.y = idx;
if(cv::norm(this_model,cv::Mat(samples,roi))<thresh_outliar){
consensus_set.push_back(idx);
}
}
// increment iteration before checking validity
iterations++;
// check validity
if(consensus_set.size() < minimum_inliar_num) continue;
if(consensus_set.size() > sampling_num){
cv::Mat refinement = fitModel(samples,consensus_set.begin()+sampling_num,consensus_set.end());
this_model = ( sampling_num * this_model + (consensus_set.size()-sampling_num) * refinement ) /consensus_set.size();
}
double this_error = calcError(samples, this_model, consensus_set.begin(),consensus_set.end());
if(this_error < best_error){
best_error = this_error;
best_model = this_model;
}
}
return best_model;
}
