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;
}
