Optimizing Boosted Decision Trees on FPGAs

# Illustrative sketch (not from the paper)
import numpy as np
import xgboost as xgb

# 1. Train trees stage‑wise on residuals
model = xgb.Booster({'objective': 'binary:logistic', 'max_depth': 4})
# placeholder data
X = np.random.randn(100, 10)
y = np.random.randint(0, 2, 100)
# initial prediction = 0
pred = np.zeros_like(y, dtype=float)
global_step = 0.1  # global step size for leaf quantization
global_bias = 0.0   # ensemble bias

for t in range(5):  # 5 boosting rounds (example)
    # fit a single tree to current residuals
    dtrain = xgb.DMatrix(X, label=y - pred)
    model.update(dtrain, t)
    # extract leaf values of the newly added tree
    leaf_vals = model.get_dump(with_stats=False)[t]
    # 2. Quantize leaf values: shift, clip, convert to non‑negative int
    shift = np.floor(np.log2(np.max(np.abs([float(v) for v in leaf_vals.split()]))))
    quantized = np.clip(np.round(np.array([float(v) for v in leaf_vals.split()]) / global_step) + shift, 0, None).astype(int)
    # 3. Fold per‑tree offset into global bias (simplified as mean diff)
    offset = np.mean(quantized) * global_step - shift
    global_bias += offset
    # 4. Update prediction with quantized leaf contribution
    pred += (quantized * global_step - shift)  # back to float space

# 5. Lower model to IR (placeholder) and generate hardware (not implemented)
print('Trained FQTree with global bias:', global_bias)

// Illustrative sketch (not from the paper)
const xgboost = require('xgboost'); // placeholder import
const tf = require('@tensorflow/tfjs-node'); // for numeric ops

// 1. Dummy data
const X = tf.randomNormal([100, 10]);
const y = tf.randomUniform([100], 0, 2, 'int32');
let pred = tf.zerosLike(y, 'float32');
const globalStep = 0.1; // global step size
let globalBias = 0.0; // ensemble bias

(async () => {
  const model = new xgboost.Booster({ objective: 'binary:logistic', max_depth: 4 });
  for (let t = 0; t < 5; t++) { // 5 boosting rounds
    // 2. Fit a tree to residuals
    const residual = tf.sub(y, pred);
    const dtrain = new xgboost.DMatrix(X, residual);
    await model.update(dtrain, t);
    // 3. Extract leaf values (mocked as an array of numbers)
    const leafVals = model.getDump({ with_stats: false })[t].split(' ');
    const leafNums = leafVals.map(v => parseFloat(v));
    // 4. Quantize: shift, clip, to non‑negative int
    const maxAbs = Math.max(...leafNums.map(Math.abs));
    const shift = Math.floor(Math.log2(maxAbs));
    const quantized = leafNums.map(v => Math.max(0, Math.round(v / globalStep) + shift));
    // 5. Fold per‑tree offset into global bias (simplified)
    const offset = quantized.reduce((a, b) => a + b, 0) / quantized.length * globalStep - shift;
    globalBias += offset;
    // 6. Update prediction
    const contrib = quantized.map(q => q * globalStep - shift);
    pred = tf.add(pred, tf.tensor(contrib, pred.shape));
  }
  // 7. Lower to IR & generate hardware (placeholder)
  console.log('Trained FQTree with global bias:', globalBias);
})();