tCmd * pS() { tCmd * cmd, *pcmd; int iteration = 0; cmd = pL(); if (cmd == NULL) return NULL; while (cur_l->type == LEX_SCRIPT) { tCmd * tmp; int type = TREL_SCRIPT; if (glhard()) { delTCmd(&cmd); return NULL; } tmp = pL(); if (tmp == NULL) { delTCmd(&cmd); return NULL; } if (!iteration) { pcmd = tmp; tmp = genTCmd(NULL); tmp->cmdType = TCMD_SCRIPT; genRelation(cmd, type, pcmd); tmp->child = cmd; cmd = tmp; iteration = 1; } else { genRelation(pcmd, type, tmp); pcmd = tmp; } } if (iteration) genRelation(pcmd, TREL_END, cmd); return cmd; }
void GenePool::pushBackIndiv(Individual& indiv) { Individual * p2Indiv = &indiv; if(LangermannPoint * pIndivL = dynamic_cast<LangermannPoint*>(p2Indiv)) { IndivPtr pL(new LangermannPoint(*pIndivL)); individualList.push_back(pL); } else if(CurveParams * pIndivC = dynamic_cast<CurveParams*>(p2Indiv)) { IndivPtr pC(new CurveParams(*pIndivC)); individualList.push_back(pC); } }
bool SplitEvaluatorMLClass<Sample, TAppContext>::CalculateSpecificLossAndThreshold(DataSet<Sample, LabelMLClass>& dataset, std::vector<std::pair<double, int> > responses, std::pair<double, double>& score_and_threshold) { // In: samples, sorted responses, out:loss-value+threshold // 1) Calculate random thresholds and sort them double min_response = responses[0].first; double max_response = responses[responses.size()-1].first; double d = (max_response - min_response); vector<double> random_thresholds(m_appcontext->num_node_thresholds, 0.0); for (int i = 0; i < random_thresholds.size(); i++) random_thresholds[i] = (randDouble() * d) + min_response; sort(random_thresholds.begin(), random_thresholds.end()); // Declare and init some variables vector<double> RClassWeights(m_appcontext->num_classes, 0.0); vector<double> LClassWeights(m_appcontext->num_classes, 0.0); vector<int> RSamples; vector<int> LSamples; double RTotalWeight = 0.0; double LTotalWeight = 0.0; double margin = 0.0; double RLoss = 0.0, LLoss = 0.0; double BestLoss = 1e16, CombinedLoss = 0.0, TotalWeight = 0.0, BestThreshold = 0.0; bool found = false; // First, put everything in the right node RSamples.resize(responses.size()); for (int r = 0; r < responses.size(); r++) { int labelIdx = dataset[responses[r].second]->m_label.class_label; double sample_w = dataset[responses[r].second]->m_label.class_weight; RClassWeights[labelIdx] += sample_w; RTotalWeight += sample_w; RSamples[r] = responses[r].second; } // Now, iterate all responses and calculate Gini indices at the cutoff points (thresholds) int th_idx = 0; bool stop_search = false; for (int r = 0; r < responses.size(); r++) { // if the current sample is smaller than the current threshold put it to the left side if (responses[r].first <= random_thresholds[th_idx]) { int labelIdx = dataset[responses[r].second]->m_label.class_label; double cur_sample_weight = dataset[responses[r].second]->m_label.class_weight; RClassWeights[labelIdx] -= cur_sample_weight; if (RClassWeights[labelIdx] < 0.0) RClassWeights[labelIdx] = 0.0; LClassWeights[labelIdx] += cur_sample_weight; RTotalWeight -= cur_sample_weight; if (RTotalWeight < 0.0) RTotalWeight = 0.0; LTotalWeight += cur_sample_weight; LSamples.push_back(RSamples[0]); RSamples.erase(RSamples.begin()); } else { // ok, now we found the first sample having higher response than the current threshold // Reset the losses RLoss = 0.0, LLoss = 0.0; // calculate loss for left and right child nodes // RIGHT vector<double> pR(RClassWeights.size()); for (int ci = 0; ci < RClassWeights.size(); ci++) pR[ci] = RClassWeights[ci] / RTotalWeight; for (int ci = 0; ci < RClassWeights.size(); ci++) RLoss += RClassWeights[ci] * ComputeLoss(pR, ci, m_appcontext->global_loss_classification); // LEFT vector<double> pL(LClassWeights.size()); for (int ci = 0; ci < LClassWeights.size(); ci++) pL[ci] = LClassWeights[ci] / LTotalWeight; for (int ci = 0; ci < LClassWeights.size(); ci++) LLoss += LClassWeights[ci] * ComputeLoss(pL, ci, m_appcontext->global_loss_classification); // Total loss CombinedLoss = LLoss + RLoss; // best-search ... if (CombinedLoss < BestLoss && LTotalWeight > 0.0 && RTotalWeight > 0.0) { BestLoss = CombinedLoss; BestThreshold = random_thresholds[th_idx]; found = true; } // next, we have to find the next random threshold that is larger than the current response // -> there might be several threshold within the gap between the last response and this one. while (responses[r].first > random_thresholds[th_idx]) { if (th_idx < (random_thresholds.size()-1)) { th_idx++; r--; } else { stop_search = true; break; // all thresholds tested } } // now, we can go on with the next response ... } if (stop_search) break; } score_and_threshold.first = BestLoss; score_and_threshold.second = BestThreshold; return found; }