hex.tree.ScoreBuildHistogram Maven / Gradle / Ivy
package hex.tree;
import hex.Distribution;
import water.H2O.H2OCountedCompleter;
import water.MRTask;
import water.fvec.C0DChunk;
import water.fvec.Chunk;
import water.util.ArrayUtils;
import water.util.AtomicUtils;
/** Score and Build Histogram
*
* Fuse 2 conceptual passes into one:
*
*
*
* - Pass 1:
- Score a prior partially-built tree model, and make new Node assignments to
* every row. This involves pulling out the current assigned DecidedNode,
* "scoring" the row against that Node's decision criteria, and assigning the
* row to a new child UndecidedNode (and giving it an improved prediction).
*
* - Pass 2:
- Build new summary DHistograms on the new child UndecidedNodes
* every row got assigned into. Collect counts, mean, variance, min,
* max per bin, per column.
*
*
* The result is a set of DHistogram arrays; one DHistogram array for each
* unique 'leaf' in the tree being histogramed in parallel. These have node
* ID's (nids) from 'leaf' to 'tree._len'. Each DHistogram array is for all
* the columns in that 'leaf'.
*
*
The other result is a prediction "score" for the whole dataset, based on
* the previous passes' DHistograms.
*/
public class ScoreBuildHistogram extends MRTask {
final int _k; // Which tree
final int _ncols;// Active feature columns
final int _nbins;// Numerical columns: Number of bins in each histogram
final int _nbins_cats;// Categorical columns: Number of bins in each histogram
final DTree _tree; // Read-only, shared (except at the histograms in the Nodes)
final int _leaf; // Number of active leaves (per tree)
// Histograms for every tree, split & active column
final DHistogram _hcs[/*tree-relative node-id*/][/*column*/];
final Distribution.Family _family;
public ScoreBuildHistogram(H2OCountedCompleter cc, int k, int ncols, int nbins, int nbins_cats, DTree tree, int leaf, DHistogram hcs[][], Distribution.Family family) {
super(cc);
_k = k;
_ncols= ncols;
_nbins= nbins;
_nbins_cats= nbins_cats;
_tree = tree;
_leaf = leaf;
_hcs = hcs;
_family = family;
}
/** Marker for already decided row. */
static public final int DECIDED_ROW = -1;
/** Marker for sampled out rows */
static public final int OUT_OF_BAG = -2;
static public boolean isOOBRow(int nid) { return nid <= OUT_OF_BAG; }
static public boolean isDecidedRow(int nid) { return nid == DECIDED_ROW; }
static public int oob2Nid(int oobNid) { return -oobNid + OUT_OF_BAG; }
static public int nid2Oob(int nid) { return -nid + OUT_OF_BAG; }
// Once-per-node shared init
@Override public void setupLocal( ) {
// Init all the internal tree fields after shipping over the wire
_tree.init_tree();
// Allocate local shared memory histograms
for( int l=_leaf; l<_tree._len; l++ ) {
DTree.UndecidedNode udn = _tree.undecided(l);
DHistogram hs[] = _hcs[l-_leaf];
int sCols[] = udn._scoreCols;
if( sCols != null ) { // Sub-selecting just some columns?
for( int col : sCols ) // For tracked cols
hs[col].init();
} else { // Else all columns
for( int j=0; j<_ncols; j++) // For all columns
if( hs[j] != null ) // Tracking this column?
hs[j].init();
}
}
}
@Override final public void map( Chunk[] chks ) {
final Chunk wrks = chks[_ncols+2]; //fitting target (same as response for DRF, residual for GBM)
final Chunk nids = chks[_ncols+3];
final Chunk weight = chks.length >= _ncols+5 ? chks[_ncols+4] : new C0DChunk(1, chks[0].len());
// Pass 1: Score a prior partially-built tree model, and make new Node
// assignments to every row. This involves pulling out the current
// assigned DecidedNode, "scoring" the row against that Node's decision
// criteria, and assigning the row to a new child UndecidedNode (and
// giving it an improved prediction).
int nnids[] = new int[nids._len];
if( _leaf > 0) // Prior pass exists?
score_decide(chks,nids,nnids);
else // Just flag all the NA rows
for( int row=0; row= 0 ) { // row already predicts perfectly or OOB
double w = weight.atd(row);
if (w == 0) continue;
double resp = wrks.atd(row);
assert !Double.isNaN(wrks.atd(row)); // Already marked as sampled-away
DHistogram nhs[] = _hcs[nid];
int sCols[] = _tree.undecided(nid+_leaf)._scoreCols; // Columns to score (null, or a list of selected cols)
if (sCols == null) {
for(int col=0; col= 0 ) nh[i+1]++;
// Rollup the histogram of rows-per-NID in this chunk
for( int i=0; i<_hcs.length; i++ ) nh[i+1] += nh[i];
// Splat the rows into NID-groups
int rows[] = new int[nnids.length];
for( int row=0; row= 0 )
rows[nh[nnids[row]]++] = row;
// rows[] has Chunk-local ROW-numbers now, in-order, grouped by NID.
// nh[] lists the start of each new NID, and is indexed by NID+1.
final DHistogram hcs[][] = _hcs;
if( hcs.length==0 ) return; // Unlikely fast cutout
// Local temp arrays, no atomic updates.
double bins[] = new double[Math.max(_nbins, _nbins_cats)];
double sums[] = new double[Math.max(_nbins, _nbins_cats)];
double ssqs[] = new double[Math.max(_nbins, _nbins_cats)];
int cols = _ncols;
int hcslen = hcs.length;
double[] ws = new double[chks[0]._len];
double[] cs = new double[chks[0]._len];
double[] ys = new double[chks[0]._len];
//Note: for (n) for (c) is faster than for(c) for(n) for Airlines and MNIST data for DRF and GBM and stochastic GBM
weight.getDoubles(ws,0,ws.length);
wrks.getDoubles(ys,0,ys.length);
for (int c = 0; c < cols; c++) {
boolean extracted = false;
for (int n = 0; n < hcslen; n++) {
int sCols[] = _tree.undecided(n + _leaf)._scoreCols; // Columns to score (null, or a list of selected cols)
if (sCols == null || ArrayUtils.find(sCols,c) >= 0) {
if (!extracted) {
chks[c].getDoubles(cs, 0, cs.length);
extracted = true;
}
overAllRows(cs, ys, ws, rows, hcs[n][c], n == 0 ? 0 : nh[n - 1], nh[n], bins, sums, ssqs);
}
}
}
}
private static void overAllRows(double [] cs, double [] ys, double [] ws, int[] rows, final DHistogram rh, int lo, int hi, double[] bins, double[] sums, double[] ssqs) {
if( rh==null ) return; // Ignore untracked columns in this split
int rhbinslen = rh._bins.length;
if( rhbinslen > bins.length) { // Grow bins if needed
bins = new double[rhbinslen];
sums = new double[rhbinslen];
ssqs = new double[rhbinslen];
}
fillLocalHistoForNode(bins, sums, ssqs, ws, cs, ys, rh, rows, hi, lo);
bumpSharedHisto(bins,sums,ssqs,rh);
}
static void bumpSharedHisto(double[]bins,double[]sums,double[]ssqs,DHistogram rh) {
final int len = rh._bins.length;
for( int b=0; b minmax[1] ) minmax[1] = col_data;
int b = rh.bin(col_data); // Compute bin# via linear interpolation
double resp = ys[k];
double wy = w*resp;
bins[b] += w; // Bump count in bin
sums[b] += wy;
ssqs[b] += wy*resp;
}
// Add all the data into the Histogram (atomically add)
rh.setMin(minmax[0]); // Track actual lower/upper bound per-bin
rh.setMax(minmax[1]);
}
}