tree::tree(data_set& train_set, int max_leafs, int max_depth) : max_leafs(max_leafs)
{
std::set<int> features;
for (size_t i = 0; i < train_set[0].features.size(); i++)
{
features.insert(i);
}
leafs = 1;
int depth = 0;
root = new node(0);
root->data_begin = train_set.begin();
root->data_end = train_set.end();
root->calc_avg();
root->node_mse = calc_mse(root->data_begin, root->data_end, root->output_value, root->size);
std::vector<node*> layer;
layer.push_back(root);
layers.push_back(layer);
while (leafs < max_leafs && depth < max_depth && !features.empty())
{
float min_error = INF;
int best_feature = -1;
make_layer(depth);
for (std::set<int>::iterator cur_split_feature = features.begin(); cur_split_feature != features.end(); cur_split_feature++)
//choose best split feature at current depth
{
float cur_error = 0;
for (size_t i = 0; i < layers[depth].size(); i++)
{
cur_error += layers[depth][i]->split(*cur_split_feature);
}
if (cur_error < min_error)
{
min_error = cur_error;
best_feature = *cur_split_feature;
}
}
for (size_t i = 0; i < layers[depth].size(); i++)
{
layers[depth][i]->split(best_feature);
}
feature_id_at_depth.push_back(best_feature);
features.erase(best_feature);
depth++;
//std::cout << "level " << depth << " created. training error: " << min_error << " best feat: " << best_feature << " split_val: "
//<< root->split_value << std::endl;
}
for (size_t i = 0; i < layers.back().size(); i++)
{
layers.back()[i]->is_leaf = true;
}
//std::cout << "leafs before pruning: " << leafs << std::endl;
//prune(root);
//std::cout << "new tree! leafs after pruning: " << leafs << std::endl;
while (layers.back().empty())
{
layers.pop_back();
}
}
void
init_goop(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int i;
XGCValues gcv;
int nblobs;
unsigned long *plane_masks = NULL;
unsigned long base_pixel = 0;
goopstruct *gp;
if (goops == NULL) {
if ((goops = (goopstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (goopstruct))) == NULL)
return;
}
gp = &goops[MI_SCREEN(mi)];
gp->mode = (False /* xor init */ ? xored
: (True /* transparent init */ ? transparent : opaque));
gp->width = MI_WIDTH(mi);
gp->height = MI_HEIGHT(mi);
free_goop(display, gp);
gp->nlayers = 0; /* planes init */
if (gp->nlayers <= 0)
gp->nlayers = (int) (LRAND() % (MI_DEPTH(mi) - 2)) + 2;
if ((gp->layers = (layer *) calloc(gp->nlayers, sizeof (layer))) == NULL) {
return; /* free_goop just ran */
}
if ((MI_NPIXELS(mi) < 2) && gp->mode == transparent)
gp->mode = opaque;
/* Try to allocate some color planes before committing to nlayers.
*/
#if 0
if (gp->mode == transparent) {
Bool additive_p = True; /* additive init */
int nplanes = gp->nlayers;
/* allocate_alpha_colors (display, MI_COLORMAP(mi), &nplanes, additive_p, &plane_masks,
&base_pixel); *//* COME BACK */
if (nplanes > 1)
gp->nlayers = nplanes;
else {
(void) fprintf(stderr,
"could not allocate any color planes; turning transparency off.\n");
gp->mode = opaque;
}
}
#else
if (gp->mode == transparent)
gp->mode = opaque;
#endif
nblobs = MI_COUNT(mi);
if (nblobs < 0) {
nblobs = NRAND(-nblobs) + 1; /* Add 1 so its not too boring */
} {
int *lblobs;
int total = DEF_COUNT;
if ((lblobs = (int *) calloc(gp->nlayers,
sizeof (int))) == NULL) {
free_goop(display, gp);
return;
}
if (nblobs <= 0)
while (total)
for (i = 0; total && i < gp->nlayers; i++)
lblobs[i]++, total--;
for (i = 0; i < gp->nlayers; i++)
if (!make_layer(mi, &(gp->layers[i]),
(nblobs > 0 ? nblobs : lblobs[i])))
free_goop(display, gp);
free(lblobs);
}
if (gp->mode == transparent && plane_masks) {
for (i = 0; i < gp->nlayers; i++)
gp->layers[i].pixel = base_pixel | plane_masks[i];
gp->background = base_pixel;
}
if (plane_masks != NULL)
free(plane_masks);
if (gp->mode != transparent) {
gp->background = 0; /* init */
for (i = 0; i < gp->nlayers; i++) {
if (MI_NPIXELS(mi) > 2)
gp->layers[i].pixel = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi)));
else
gp->layers[i].pixel = MI_WHITE_PIXEL(mi);
}
}
if ((gp->pixmap = XCreatePixmap(display, window,
MI_WIDTH(mi), MI_HEIGHT(mi),
(gp->mode == xored ? 1 : MI_DEPTH(mi)))) == None) {
free_goop(display, gp);
return;
}
gcv.background = gp->background;
gcv.foreground = 255; /* init */
gcv.line_width = 5; /* thickness init */
if ((gp->pixmap_gc = XCreateGC(display, gp->pixmap, GCLineWidth,
&gcv)) == None) {
free_goop(display, gp);
return;
}
MI_CLEARWINDOW(mi);
}
