Skip to main content

Gradient Boosted Decision Trees (GBDT)

Description​

The GBDT (Gradient Boosted Decision Tree) is a high-performance learning-to-rank policy designed to transform user interaction history and metadata into a precise numerical score. It is an ensemble method that trains a series of decision trees sequentially. Each new tree is optimized to correct the prediction errors of the previous ones.The final output is the weighted sum of all trees, which can be interpreted as a predicted engagement rate or click-through rate (CTR) for a given user-item pair.

The Shaped GBDT policy fits a gradient-boosted decision tree model using the LightGBM framework on features defined by the Signal Engine (declarative feature_definitions: lookups, aggregations, crosses, multi-hot encodings, vector-derived signals, and more).

Policy Type: gbdt
Supports: scoring_policy

Premium Model

This model requires the Standard Plan or higher.

Hyperparameter tuning​

  • name: Optional display name for the policy instance.
  • feature_definitions: List of Signal Engine signal definitions (lookup, aggregation, cross, multi_hot, etc.). When omitted, the policy falls back to the following features:
    • user and item metadata column whose type is Numerical, Binary, or Boolean, it adds a lookup signal (the user and item ID columns are skipped, and other types—e.g. plain categories or text—are not included by default).
    • two interaction-count signals: a rolling count of interactions per user over 7 days and over 30 days (time-windowed aggregations on the interaction spine).
  • objective: Objective function. Tunable search typically exposes binary and regression; the implementation also supports poisson, lambdarank, and rank_xendcg where applicable.
  • n_estimators: Number of boosting iterations (trees).
  • max_depth: Maximum depth of the tree. -1 means no limit.
  • num_leaves: Maximum number of leaves in one tree.
  • min_child_weight: Minimum sum Hessian in one leaf.
  • learning_rate: Learning rate (shrinkage) for gradient boosting.
  • colsample_bytree: Subsample columns on each iteration.
  • subsample: Subsample training data on each iteration.
  • subsample_freq: Bagging frequency.
  • zero_as_missing: Treat zero values as missing.
  • bin_construct_sample_cnt: Number of samples used to construct histogram bins.
  • verbose: LightGBM verbosity level.
  • verbose_eval: How often to log evaluation metrics during training.
  • num_threads: Optional thread count for LightGBM (default uses library defaults).
  • lambdarank_truncation_level: Number of pairs used in pairwise loss; should be slightly higher than the k used for NDCG@k when using ranking objectives.
  • early_stopping_rounds: Number of rounds without validation improvement before stopping (optional).
  • force_col_wise: Use column-wise histogram building (often reduces memory).
  • calibrate: Whether to calibrate output probabilities (common for binary classification).
  • enable_resume: Whether to enable resume from checkpoints.
  • balance_labels: Whether to balance labels for interaction training.
  • use_session_interactions: Whether to pass session interactions into online signal resolution for time-windowed features (disable if you do not need session-based signals at score time).

Usage​

Use this model when:​

  • You want a strong tabular baseline for ranking or classification (e.g. click, purchase, engagement) with rich user, item, and interaction-derived features.
  • You know which features matters the most: use declarative feature engineering via the Signal Engine (feature_definitions).
  • You care about interpretability relative to deep models (via tree splits and gain-based importance from LightGBM).
  • You are building a multi-stage system where a GBDT re-ranks candidates retrieved by retrieval or embedding models.
  • You want a learning-to-rank objective such as LambdaRank/LambdaMART for slate ranking
  • You need a production-ready, memory-efficient GBDT implementation with strong baseline performance
  • You want to combine rich feature sets (behavioral, content, and affinity features) into a single scoring model

Choose a different model when:​

  • You only need a simple trending or heuristic baseline (use Rising Popularity or value-model expressions)
  • You have unstructured data like raw images or high cardinality text features where deep learning architectures (CNNs, Transformers) are more effective than tree-based models
  • You want sequence-aware behavior without hand-built sequence features (use SASRec, BERT4Rec, or similar).
  • You have interaction-only sparse data and little metadata (use ALS, ELSA, or other collaborative filters).
  • You want high-order nonlinear interactions learned end-to-end from raw text or images without heavy feature design (use Two-Tower, content similarity, or hybrid deep models).
  • You want to explicitly learn high-order feature interactions via deep networks (use DeepFM or Wide & Deep)
  • You have extremely sparse interaction-only data and no rich feature set (use ALS/ELSA or other embedding models)

Use cases​

  • E-commerce CTR prediction and ranking for product search and browse results
  • Feed ranking and homepage personalization using mixed behavioral and content features
  • Purchase or add-to-cart prediction with catalog and behavioral features.
  • Re-ranking retrieved candidates using crosses, multi-hot categories, and rolling aggregates.
  • Prototyping signal definitions before committing to heavier neural training.
  • Any recommendation or ranking task where gradient boosted trees on engineered signals are an appropriate fit.

References​