Boosted Trees on a Diet: Compact Models for Resource-Constrained Devices
Authors: Nina Herrmann
Jan Stenkamp
Benjamin Karic
Stefan Oehmcke
Fabian Gieseke
Venue: ICLR 2026 Poster (2026)
Keywords: TinyML
Boosting
Decision Trees
Microcontrollers
IoT
Primary area: other topics in machine learning (i.e., none of the above)
TL;DR: Compressing boosted decision tree ensembles by efficient reuse of features and threshold values combined with a bitwise encoding.

Abstract: Deploying machine learning models on compute-constrained devices has become a key building block of modern IoT applications. In this work, we present a compression scheme for boosted decision trees, addressing the growing need for lightweight machine learning models. Specifically, we provide techniques for training compact boosted decision tree ensembles that exhibit a reduced memory footprint by rewarding, among other things, the reuse of features and thresholds during training. Our experimental evaluation shows that models achieved the same performance with a compression ratio of 4–16x compared to LightGBM models using an adapted training process and an alternative memory layout. Once deployed, the corresponding IoT devices can operate independently of constant communication or external energy supply, and, thus, autonomously, requiring only minimal computing power and energy. This capability opens the door to a wide range of IoT applications, including remote monitoring, edge analytics, and real-time decision making in isolated or power-limited environments.

Published as a conference paper at ICLR 2026
BOOSTED TREES ON A DIET: COMPACT MODELS FOR RESOURCE-CONSTRAINNE DEVICES
Nina Herrmann's ; Jan Stenkamp's Benjamin Karic', Stefan Oehmeke Fabian Gieseke! 1.3 Universitty of Münster. Universitty of Rostock, 'University of Copenhagen (nina. herrmann, jan. stenkamp) eunimmenster.r........
ABSTRACT
Deploying machine learning models on compute-constrained devices has become key building block of modern IoT applications. In this work. present compression scheme for boosted decision trees, addressing the growing need for lightweight machine learning models. Specifically, we provide techniques for training compact boosted decision tree ensembles that exhibit a reduced mem- ory footprint by rewarding, among other things, the reuse of features and thresh- olds during training. Our experimental evaluation shows that models achieved the same performance with compression ratio of 4-16x compared LightGBM models using an adapted training process and an alternative memory layout. Once deployed, the corresponding IoT devices can operate independently of constant communication or external energy supply, and, thus, autonomously, requiring only minimal computing power and energy. This capability opens the door to a wide range of IoT applications, including remote monitoring, edge analytics, and real- time decision making in isolated or power-limited environments.
INTRODUCTION
Modern Internet of Things (IoT) techniques have paved the way for new applications in domains such as home automation, healthcare, agriculture, or industry (Khanna & Kaur 2020). For instance, in the context of home automation, sensors can be used automate (smart) lighting and (smart) heating. Another example is using sensor data for predictive maintenance to prevent machine fail- ures and enhance productivity. Microcontrollers often equipped with sensors to measure parameters such as temperature, humidity, pressure, or vi- brations. A key characteristic of such devices is that they generally have very limited computing and memory resources (Ojo et al. 2018). For instance, the broadly used open-source Arduino Uno R4 Minima board equipped with a 32-bit Renesas RA4M/ microcontroller and an Arm Cortex- M4 processor running at 48 MHz, 32 KB main memory (RAM), 256 KB flash storage, and 1 KB electrically erasable programmable read-only memory (EEPROM). There are also microcontrollers with even less memory and computing resources, such as the Arduino Nano board. Furthermore, the available resources must be shared among the operating system, sensing data, data data-processing pro- often
a key building block of these IoT applications,
grams, and machine learning models. Another characteristic is that IoT microcontrollers designed for energy efficiency. This makes them well-suited for being deployed in remote locations, where continuous power supply is not available. Under ideal conditions, such devices for several months or even years via batteries. Such applications are also supported by specialized communication protocols such as LoRa !
To minimize energy-intensive data transfers and to enable real-time processing, the on-site analysis of data on the loT device is preferable if possible. Embedding machine learning methods directly into ToT nodes addresses this need. The key challenge in embedded machine learning is to minimize both compute and memory requirements enable exccution on resource-constrained devices while, at the same time, preserving model quality. This has given rise to the concept of Tiny Machine Learning (TimyML) models (Gural Murmann 2019 Reddi al., 2021 Kumar et al., 2017; War- den & Situnayake, 2019). By sufficiently reducing resource demands, the "tiny" models can be run
"Equal contribution.
LoRa enables small volumes of data be transferred over several kilometres (Mayer et al. 2019

---

Published as a conference paper at ICLR 2026
directly the microcontrollers, enabling compact "smart" devices. An example of corresponding loT application is sketched in Figure
Contribution: We propose framework that allows for compressing boosted decision tree ensem- bles, one of the most widely used machine learning models for structured data. Our approach, referred to as Trees
Diet (ToaD), relies (1) regularizers that encourage the reuse of features and thresholds during training and on (2) a specialized memory layout to store the resulting trees. More precisely, we utilize global lookup tables for both features and thresholds, and we store the trees without pointers using an adapted bit-wise encoding. Overall, these modifications lead to tree ensembles with reduced memory requirements, without sacrificing model quality. We showcase the effectiveness of our approach by assessing the quality-memory memory trade-off in our experimental evalua- tion. Our results indicate that the adapted training process yields models of comparable performance while achieving compression ratios of 4- 16x compared to other baselines.
2
BACKGROUND
Sensors
Microcontroller
We begin with the background on boosted de- cision trees and tiny machine learning models.
2.1 BOOSTED DECISION TREES
densor dota
send worning?
In contrast to single decision trees, tree ensem- bles aggregate the outputs of multiple trees. For instance, random forest (RF) (Breiman] 2001) is obtained by constructing the trees in- dependently from each other, introducing ran- domness to the construction process so that set of different trees is obtained. In contrast, boosted decision trees are built in an incremen- tal manner, one tree at a time. Two prominent frameworks in this context XGBoost (Chen & Guestrin 2016) and LightGBM (Ke et al. 2017).
Tiny Tree
Figure 1: A machine learning model (decision tree) on microcontroller processes multi-sensor data locally and transmits only relevant events, re- ducing energy costs; the decision tree must have minimal compute and memory footprint.
Let T = (1),,)1),.... (x): }n]} C Rd x y be training (multi)set of data points x, E Fd with associated labels y/ V. Here, y is the set of labels. For regression, we have y = R. whereas one is given finite set ) {pi..... Pef } of classes for classification scenarios. Both XGBoost and LightGBM model ensembles are built an additive way, resulting a tree ensemble model T, whose prediction T(x) for new data point x E Rd is based on the sum of predictions made by K individual decision trees th i.c., T(x) = ΣK (x(),, where tu (x) denotes the prediction made by the tree 4g for instance E Rd. Such ensembles are built in way minimize
EC(,.T(x.)) + Σ (ts),
(I)
where L: L: - R+ is suitable loss function and where Ω (fx) specifies the complexity of the tree tg. Constructing an optimal tree ensemble T w.r.t. Equation ① is generally not feasible. Instead, one typically resorts to K boosting rounds, and in each round, one new tree is added to the ensemble built so far so that the Equation 1 is minimized. More precisely,
boosting round m 2 1, one m-1 1 of the trees built so far, starting with To = 0, and aims considers the ensemble Tm-1- == k=
to find the next best tree fm that minimizes Σn= C (y:, + fm (x,)) + Σm l(xx). The decision tree f. itself is also constructed in greedy manner, starting with the root of the tree being recursively split. To penalize "complex" trees, one usually resorts a(m)) >L + f E| of as regularizer, where I. is the number of leaves and "1,...,7h, Ug. E IR. the associated leaf values of t.m.
2.2 RELATED WORK
Decision trees and decision tree ensembles, such as Gradient Boosted Decision Trees (GBDT), have remained very popular, despite the rise of deep learning models (Grinsztajn al. 2022), especially
2

---

The standard gain does not promote the reuse of features or thresholds. Following Peter et al. (017). introduce additional regularizer based the set of features Fu C (1,.... : d) and thresholds Tf C IR with f E Fy that have already been used by the trees f,...., f. built so far (including the Published as a conference paper at ICLR 2026
for structured (tabular-like) data. They are also generally easy interpret and need few compu- tational resources. Recent advances in tree-based models have also introduced several approaches
to enhance their efficiency. For instance, several works focused on improving the training in-
ference speed of GBDT by means of array structures (Lucchese et al.,
2017 Ye et al. 2018) or
via the quantization of gradient statistics (Shi al., 20022 Jiang et al.] 2018 Devos et 2020)
Quantization of tree parameters was employed by Koschel et al. (2023). who adapted variants of QuickScorer (Lucchese et al. 2017) enable deployment on IoT devices. Moreover, quantization of GBDT for
devices was investigated by Alsharari et al. (2025) and Wang al. (023). both targeting FPGAs. Reduction of model size and latency the motivation for dif- ferent post-training pruning techniques (Liu & Mazumder] 2023 Guo et al. 2018)) some including the refinement of leave values (Devos et al., 2025] Emine et al. 2025| Buschjäger & Morik, 2023). Increased efficiency of tree models by design or within the training process is addressed by works from Kumar et al. (2017) for single decision tree sizes, Ponomareva et (011)) for multiclass clas- sification, and Peter et al. (2017) for efficient evaluation of deep trees considering feature acquisition and tree evaluation costs. Further work focusing primarily on the optimization of RFs include |Ren eet al.) (2015). Allhoury al.) (2025), and Nan et al.] (2016). Due lack of space, we refer to Appendix C for a more detailed discussion of related approaches.
In this work, we focus on gradient-boosted trees. For subsequent deployments, our aim is to min- imize the memory footprint of the ensemble during the training process, while simultaneously en- suring good model fit and compact model size. We extend the work of Peter et al. (2017) by defining suitable feature costs that aim at reducing the bits required to encode feature indices. We also introduce a corresponding cost regularizer for split thresholds and leaf values, and provide specialized encoding for the induced binary trees. Moreover, our memory layout includes global threshold arrays shared by all learners.
APPROACH
Pruning or quantization techniques are typically applied before or after the training to reduce the size of trees (see Section A. However, such methods generally cannot exploit task-specific compression potential. For instance, they are not designed to incorporate the potential in memory saving of feature sharing the reuse of (lcaf/split) thresholds within a single tree or across all trees in the ensemble. Our framework exploits this potential by penalizing unused features and thresholds when growing new trees. In combination with corresponding memory layout, this yields substantially smaller memory footprint with reused features and thresholds being stored more compactly!
3.1 TRAINING COMPRESSED TREES
As sketched above, boosted tree ensembles are built in an incremental manner, and in each boosting round m, new tree fm is added to the ensemble. The tree f. is, in turn, also built in a greedy manner by iteratively splitting leaves (starting with the root) if this leads to a better objective (if not, the construction process stops). To assess the quality of such leaf split, an associated gain A is computed (Chen & Guestrin 2016). More specifically, for leaf associated with a set / of training indices, a split along feature dimension i E {I,..., d} with respect to threshold f induces a potential gain A(I, i, μ4) E I (which may also be negative). Leaves are split as long as some split yields a positive gain, always choosing the Icaf and split with the highest gain.
current tree l.). The memory layout detailed below allows for storing those features and thresholds in a much more compact manner. In particular, features and thresholds that have already been
*Our work targets resource- -osstrre-d devices where memory. not latency or energy, is the main bottle- neck. In many applications, the model size determines whether deployment is feasible or not. It is worth pointing out that local on-device inference is generally far more energy-efficient than transmitting data to a remote server and also incurs only minimal latency. Technically, our compression scheme adds only minimal overhead (a few wit- operations), so we expect the impact on latency and energy per prediction to be neg- ligible. Preliminary insights on prototypical implementations of TeaD and LightGBM deployed on different micracontrollers are discussed in Appendix E.
3

---

Published as a conference paper at ICLR 2026
Feature
Globol Features Thresholds featore A
Global
Trees
nack of trees Intege?)
renter witluff (20 lis bineper?
Treed
00....0
01...1
0...1
(F2) seal fealuems
(elut (nteger)
Testure F.Fo
High-level sketch of the memory layout used to store an ensemble of boosted decision trees. The first part stores some metadata, such as the number K of boosted trees or the maximum depth of all trees. The following three parts encode the used features, thresholds, and leaf values. Finally, the references to the features and thresholds for the individual trees are stored.
Figure 2:
used in previous trees contribute only marginally to the overall space consumption and are therefore essentially "free of charge". simple linear regularizer that favors such a reuse of features and thresholds is given by
(tm) = (2mm) + |uul + &. ETT JEFu
where E E R+ are user-defined hyperparameters. Thus, using new feature that has not been used so far leads an increase of |Ful by 1, and, hence, to an increase of the objective ① by Accordingly, if new threshold is used for feature E Fu, the objective is increased by { Using this modified regularizer leads to the following modified gain
(3) in case new feature (index) is used and y otherwise, and 8, in case a new threshold is used and 9; 0 otherwise, see Appendix A for the derivations.
(,, = A(I, ( (1) - Syl $45.
where 8y
3.2 MEMORY LAYOUT
Our memory layout leverages the reuse of feature indices and thresholds enforced by the modified regularizer. A high-level sketch the overall memory layout shown in Figure 2 reduces the memory footprint of boosted tree ensembles through two mechanisms:
In a nutshell,
Bit-wise encoding: Encoding the information a bit-wise manner allows to store a minimal representation of information compared to the use of higher level data types that may use non minimal representations (e.g. a bool occupies eight bits in memory in C).
2. Shared thresholds and values: Global arrays are used to store threshold and leaf values, which are referenced within internal tree nodes and leaves. Sharing values across trees can substantially reduce the bits needed for storing thresholds and leaf weights.
The memory layout comprises five components. The first stores metadata, including the number K of trees, the maximum tree depth, the number |Fell of used features, and the maximum number of thresholds fax [T'| associated with any feature. In addition, three global arrays and the individual decision trees t,,..., tk are stored. Figure Jillustates the bit-wise encoding simple model with two exemplary decision trees. We now detail the individual components.
3.2. BIT- WISE ENCODING
Boosted ensembles typically employ shallow, nearly balanced trees with small depth (e.g., a depth of up to 5). Such trees can be stored efficiently using pointer-less schemes. More precisely, the root is stored at index i = 0, and for node at index i, the left child is stored at index 2 . i + and the right child at index
+ For example, in Figure B two such array-based representations are given. Here, the root nı of tree l is stored at index O, and its two children n2 and na are stored at indices and 2, respectively. We distinguish between internal nodes and leaf nodes:
FFor example, if a feature corresponds temperature values, it may be sufficient to restrict set of missible thresholds to, e.g., 0 and 20 degrees Celsius. Alternative regularization schemes are also conceivable. Another option is. for instance, Q2 (I..)) 2((m.) + c. Σ}Ey + E with p E [T which imposes exponentially increasing penalty the number of distinct features and thresholds. In practice, however, the linear regularizer has heen shown be highly effective and is, hence, used in this work.
4

---

Published as a conference paper at ICLR 2026
Exarplle Datsoat
Trans
VI MI.
Fanturer (.33..4
Used
(LA.
AC
Fealure Throshold
Newirh P
loc
0B 2
1 23
-22
10000
3" MR
3:
yol
3014
10r
Close Lest Wauue CD be Toaa
0000101
1000000
11.6910
Figure 3: Illustration of a bit-wise encoding of boosted tree ensemble with two trees, Each tree is stored in bit-wise manner, with each internal node storing a reference to a feature index and reference to a threshold index. For instance, for the left child n2 of the root of the tree f1, a reference to feature f2 is stored along with reference to the associated threshold μ.z. For feature f2, there are two thresholds used by the entire ensemble, namely sf and μ33, which can be used by any node of any of the trees (e.g. t2 in node nz). Accordingly, the leaf values stored in the leaves of the trees are shared (e.g. U4 is used in leaf (4 of tree & and leaf L of (2) and stored in one array. Since the bit-size of the thresholds varies, additional metadata is stored in the Feature & Threshold Mapping table/array. For instance, there are two thresholds for feature fi of bit-size 2 (i.e., four different values), whereas there are two 1-bit thresholds for feature fe.
Internal nodes: For each internal node n,, two pieces of information are stored, namely reference for the feature Si Fo that is used for splitting along with an index for the associated threshold value n0} (j-th threshold associated with feature fi). For instance, for tree to and node n21, we store reference 10 for feature fa and an index for the associated threshold p.. The reference 10 can be used to loop up the relevant information in the Fea ture
Threshole d Map. this case, fa corresponds to the fourth feature, 2 bits are used to represent the thresholds (floating point), and one threshold was used overall for that feature. Using the index 0 and along with the information stored for the other features, one can then loop up the threshold value μi.
Leaf nodes: For each leaf node, reference to its leaf value v is stored. For instance, for the leaf I of tree t1, reference 000 to the leaf value en is stored. All these leaf values are shared across all the trees and are stored in the array Global Leaf Values.
The details for each feature are stored in bit-wise manner in the array Feature Thresholds Map that is referred to when decoding the nodes. To process such a reference we need to know the bit widths of following information:
(a) Input feature index: For a given dataset with features F, (1.....,d ........], d), the num- ber d of features is known and can be encoded using [log)([Pr()] bits.
(b) Threshold bit-width: Threshold values are assumed be representable as 1-bit (binary feature), 2 2-its (small integers), or 8) 16]332-bbss (floating point with different pre- cision or integers). The threshold bit-width per feature can be stored as a power of two, requiring only three bits to represent the aforementioned values (2" to 25).
(c) Threshold numeric type: The representation be either floating point number (float) or a fixed point number (integer), and can be stored using a single bit, allowing for big integers and floating point values be used.
(d) Number of thresholds: The maximum number max [T'] of thresholds among all features can be determined training time and can be encoded using [log2 (max Pa [T'1]] bits. Since features with 0 thresholds are not included, we map the value 0 to the threshold count (i.e., the bit value +1 is the actual count).
5

---

Published as a conference paper at ICLR 2026
Hence, the array-based representation Trees of the trees , .x along with the Feature Threshold Map are used to store the trees and additional information to retrieve the actual split feature indices and thresholds and leaf values in the two global arrays, which are described next.
3.2.2 SHARING THRESHOLLDS AND LEAF VALUES
The threshold values stored on per-feature basis in single array, Global Features Thresholds in Figure 3 which is referenced by nodes throughout the entire tree ensemble. For example, consider tree node ny referencing the first feature, f1, along with its corresponding first threshold, μi, as depicted tree 1 in Figure 3 The Feature & Threshold Map allows for calculating the offset for each feature by determining the memory consumption of all previous features. Therefore, the associated threshold value (i.e. 10 for pt) can be extracted and decoded to its original representation (i.e. 10 (inl)2 for μ4). This permits the variation of both the bit size and precision between different features within single array.
The leaf values are stored (globally) in the array Global Leaf Values using fixed 32-bit floating point representation. This allows for high precision in leaves and a reuse across the different trees in the ensemble without feature reference. For example, consider the fourth global leaf value 14 in Figure which is referenced by both the leaf l in tree t and leaf 4 of tz.
4 EXPERIMENTS
To assess the quality of our compression approach and the impact of the additional parameters on the results, we ran three kinds of experiments: (1) performance comparison of ToaD with other GBDT and tree ensemble optimization methods, (2) an univariate sensitivity analysis evaluating the threshold and feature penalties independently, and (3) a multivariate analysis combining both penalties. For the evaluation, the ToaD models were trained with varying hyperparameters (grid- search). The maximum number of iterations ranges from 20 to 20 maximum depth per tree from 2 to 23, and and & from 2- 2 Moreover, and & were set to 0 in every possible combination. This results 32,076 models trained per dataset.
4.1 IMPLEMENTATION DETAILS
Our implementation builds upon the LightGBM framework The penalties were added as op- tional hyperparaneters to the training process of GBDT. The parameter is introduced as variable toad saddpenalty w.lpeaalllfffttttt fratffeauureee and & as variable todd penalty. wenalty.hhreshol threeheold.. Moreover, logging
the used features and thresholds enables tracking of the memory consumed by the selected memory layout. Therefore, the optional variable toad.forestsize allows training models for a specific memory limitation (such as 32KB collection of cight widely used publicly available datasets (see Appendix B for specifics). We split all datasets into training and test sets using an 80/20 ratio. For the two smallest datasets, i.e. Breast Cancer and kr-vs-kp, we used 5-fold cross- cols-vvaliotiion on the training data, while for bigger datasets used 10% from the training data as validation data. Model fitting was conducted on the training set, and the test was used to measure the final induced quality of the models. As metrics for quality measurement of the resulting models, accuracy is used for classification datasets and the R² score for regression datasets (Lewis-Bec Beck & Lewis Beck 2015). Note that, for both metrics, higher values indicate better model performance.
Arduino Uno Rev 3). Experiments were conducted
4.2 MODEL COMPARISON TO BASELINES
We compared the performance of approach to that of other efficient GBDT (compression) methods. LightGBM is considered an established framework for training boosted trees (Ke et al., 2017). It was used for comparison in both the standard and quantized version. For quantization, the threshold and leaf values were reduced to 16-bit floating point precision. In addition, LightGBM was evaluated an array-based structure, i.c., was stored without pointers but assuming all trees are complete as described in Section 3.2.1 This allows the comparison between ToaD and
All the source code and the experimental https://github.rr wht.h//ghh///ght.tootoo..
setup are
available the repository:

---

Published as a conference paper at ICLR 2026
mushroom (binary)
coutype (binary)
breastcancer (birary)
kr (birary)
1,000
LipicOV amp-bred
Lighcou 1116
Lightao
0.88
2.89
0.003
0.000
C200
60
0.905
Foi Peration
78
0.993
0.000
0.8
kindmm (regression)
califoriia housing (regression)
wine (multidass)
coviype muti (muitilass)
F22 02:00
00
3125 75-40 IDADD
Mao Maraay (02)
Marrery (KB)
Maa Merrory (K3)
Nax Merroy (12)
Figure 4: Accuracy vs. memory (KB) for ToaD and baselines. All models were trained on 12 train-test splits and the best model performance at given memory limit from the hyperparameter analysis is depicted. The points show the mean across the splits, the errorbars show the respective standard deviation.
LightGBM under a unified pointer-less layout. Moreover, different pruning methods were evalu- ated with cost-efficient gradient boosting (CEGB) (Peter et al.) (017) and minimal cost-complexity pruning (CCP) (Breiman et al. 1984). All models were trained with the same hyperparameters as the ToaD models, i.e. all combinations of 2 to 20 maximum trees and maximum tree depth be- tween 2 and 23_ For all datasets we used 1- 12 as random seeds for the data split. Alongside related work (e.g., (Buchhääer & Morik 2023). ) we calculated the memory usage of model with 128 bits per node assuming all values are stored in single precision (float32) and 64 bits for quantized half- precision models [ In constrast to Buschjäger & Morik (2023), we assume the information about node being Icaf can be encoded by specific feature and child node identifier, thus no additional boolean values are required. Moreover, boosted trees do not need to store the class information within a leaf but create one ensemble per class for multiclass classification problems.
For the calculation of the memory footprint of the ToaD models, the proposed memory layout is used. For the ToaD models, it is distinguished between the memory layout without applying penal- ization during training, i.e., 4. = and E 0, and the best- best-performing models with penalization. For the comparison visualized in Figure 4 the best-performing models with a memory consump- tion less than or equal to the respective upper limit were chosen from the grid search results. Thus, the number or depth of trees of models at the same memory limit for the same dataset may differ for different model types. We expect ToaD to outperform the baseline implementations as it does not require pointers to its children, it encodes boolean values with only 2 bits, and suitable penalty configuration encourages the model to reuse features and thresholds. Thus, ToaD especially benefits from the pointer-less tree layout, which is strong for complete trees, whereas standard child-pointer layout also allows deeper non-complete trees without wasting too many resources.
4.2.1 RESULTS BASELINE COMPARISON
Penalty Grid Search, Califomia Housing, 1 KB
213
0.6
Since the primary use case for ToaD is microcon- trollers, typical memory limits are considered for the respective performance comparison. The results are depicted in Figure 4 For almost all investigated configurations, ToaD outperforms the baseline ap- proaches, even more when considering the models from the penalized training. On all tested multiclass datasets, the ToaD approaches are superior to the other models across all memory limits. The same holds for the regression datasets until the perfor- mance saturates, starting with different memory lim- its, with some of the competitors catching up to the same score with increasing memory available. the
0.5
Festure Fonalty
2
0.4
2a
2-
0.2
2-
0.1
2-7
2
2
Threshold Penalty
Figure 5: Model performance on California Housing with a KB memory limit under varying penalties.
Faah node stores four values: one feature identifier, one threshold, and child pointers.

---

Published as a conference paper at ICLR 2026
califoria housing (ragressenn)
Knn@mm (reg Tea lon)
covtype (hinary)
breasscaner (hinary)
trys (binery)
mustroom [aimery)
NFCC Imu Riclas)
COVEYDC, musi Imuutelaas
30
30
:25
2.0
Parely
Naalrd Pandly
Netrrt Naw
Foulurs Nanulty
Peelure Faiuly
Fallur Forelly
Poulas Perdly
Toulard Panulyy
1.4
1200
2300
-5000
2.5
2.0
3.0
2131
2-5
pagarg 31
2-9-1" peg
3- 3
27
Threahold Fandly
Thratool Furaly
Thronold Pamily
Throstld Panaly
Thraato Nama
Thraaard fanally
Threahold Fanuly
Threahold Fanuky
Vidl Ny
Reuso tatter
Figure 6: Influence of penalties i and & on the number of thresholds and the number of features, displayed the right y-axis, alongside the respective performance scores shown on the left y- axis. The threshold penalty figure additionally depicts the reuse factor. The maximum number of iterations per model is set to 256 during training with maximum tree depth 2.
interesting memory range up to 128 KB, before some model performances saturate, the competing methods need 4 to 16 times the memory to achieve the same performance. For example, the Covertype multiclass dataset, the best ToaD model at KB achieves an accuracy of 69 %, which quantized LightGBM as the best competitor only matches with 8 KB, while float32 LightGBM even needs 16 KB. A further finding includes that ToaD outperforms array-based LightGBM, showcasing the effectiveness of our approach beyond the pure pointer-less layout.
shows an exemplary grid for model performances at a given memory limit for the California Housing dataset. The maximum memory size is fixed, allowing for an unlimited number of trees and nodes. As the forests sirestsize ze parameter determining the memory limitation can be set by the user within our implementation, this graph can easily be generated for any memory size to determine the best penalty configuration. This approach helps identify the best-performing model for given dataset on memory-limited limited hardware
Figure shoows
4.3 UNIVARIATE SENSITIVITY ANALYSIS
We conducted univariate sensitivity analysis of the two newly introduced penalties assess their individual effects on the model. During training, we varied the feature penalty and the threshold penalty & independently over the range 2-10 215, setting the other parameter to zero. We then tracked the number of nodes and leaves, the number of global values (thresholds and Ieaf values), and the test set performance. Furthermore, to evaluate how efficiently threshold values were reused, we calculated the reusing factor (ReF) as the ratio between the sum of the nodes and leaves and the global number of values. In a naive implementation, the number of leaves and nodes equals the count of values, resulting in ReF = 1. With the ratio ReF, we can determine how many of these values are reused by the ToaD approach. For instance, a value of ReF = 1.5 can be interpreted as a model reusing 50% of its threshold and leaf values, while ReF 2.0 indicates that, average, each value is used twice. Results of this analysis are depicted in Figure with a maximum number of iterations of 256 and maximum depth per tree of 2, as ToaD is meant be especially useful for shallow trees. A selection of results for further hyperparameter settings can be found in Appendix E.2
4.3.1 RESULTS FEATURE PENALTY
Figure 6 (top) shows the univariate sensitivity analysis for the feature penalty L. For & < 1, the number of features is largely unchanged, except for notable drop in the Breast Cancer dataset. The value of the feature penalty at which it takes effect varies between different datasets. For datasets with few features (California Housing and kin8nm), the accuracy drops shortly after the number of features decreases. We assume the few features in this dataset are essential for accurate predictions. In contrast, datasets with more features show slower and later accuracy decline, as the penalty first removes less relevant features. For example, the Covertype model loses only z 2% accuracy when 1 12 while the feature count drops from 35 5.
A script to reproduce the figures is available in the repository.
8

---

Published as a conference paper at ICLR 2026
california salifrrni_hhousing (regression)
kdn@nm fregression)
breasticancer (binary)
multi
(binary)
(binary)
(binary)
(multiclass)
(muhiclass)
Rohur Ponato
29.3
24
22.0
146533
7.3
Fortre Peratt
R2 (ngghcoun))
93
2-
2
Threshold
Threshids Ferally
PrestoiiPenatt
Threshold
Threshold
Threstold Fenalty
Threshold Peralty
Figure 7: Influence of z and & on the needed memory (KB) and the representative metric (accuracy or R score). Orange dots mark penalty configuration combinations that are good trade-off between model accuracy and memory. The maximum number of iterations per model is set to 256 during training with maximum tree depth of 2.
4.3.2 RESULTS THRESHOLD PENALTY
In the bottom row of Figure the performance metric for the model, the number of global values, and the ReF are depicted against a varying threshold penalty &. For all datasets, an increase in the threshold penalty decreases the number of global values used by the model. For the maximum penalty g 215, the number of global values approaches for all models, i.e., the model only consists of one tree with the root node. The trend of the performance metrics differs between the datasets. The accuracy drops abruptly after a certain penalty for most the binary datasets, whereas the performance of the other datasets declines more gradually. The models trained on the Covertype dataset record the slightest decrease of about 6% from the smallest to the largest penalty value. At the same time, the number of values used for the model drops from 1323 only 18. These differences probably arise from the size of the datasets, as the more stable models have more data points choose from.
The reuse factor follows a similar pattern across all datasets. At first, it increases for higher penalties, but with very high penalties, it starts decrease abruptly. At its peak, every model achieves ReF of at least 1.5 with the Wine dataset reusing each value more than three times for penalty around 28. In contrast, for the highest investigated threshold penalty of & 215 all models except for the Covertype dataset result in ReF = 1, meaning each value is only used once per feature. This decrease ReF for very high values can be explained by fewer global values being available for reuse, thus reducing reuse opportunities across training splits. Interestingly, the Re drops later than the number of values; actually, first increases, and with the sharp decrease of the ReF, also the accuracy plunges. Of special interest for the training process the penalties with ReF peaks, as here the model performance is still satisfactory, but the number of global thresholds is low.
4.4 MULTIVARIATE SENSITIVITY ANALYSIS
To assess the combined effects of penalties, performed multivariate sensitivity analysis for both penalty parameter values. As in the univariate sensitivity analysis, we used the parameter space 2-10 to 215 for both parameters, resulting in 26 26 676 trained models per dataset and tree setting. Figure 7 shows the memory consumption next to the performance metric in a grid of the combined penalties with maximum of 256 iterations with a maximum tree depth of A selection of results for further hyperparamter settings can be found in Appendix E.3
The memory requirements for all datasets decreased significantly as penalties increased, with each dataset having specific threshold at which memory usage drops rapidly. The different looks of the multiclass dataset memories are reasoned by them using one tree ensemble per class; thus, more trees and memory are needed. For the larger datasets (Covertype, California Housing), the difference in memory consumption is stronger, starting at around KB for small penalties and dropping to around 80 Byte for larger penalties. On average, predictive performance is better for smaller penalties as more features and thresholds are used. Independent threshold in the feature penalty, model predictions not better than guessing. This is expected as the penalties reduced tree complexity, thus it loses its predictive capabilities with the omitted features and thresholds.
the dataset and objective, after a certain

---

Published as a conference paper at ICLR 2026
By combining both penalty parameters, we select model that maintains high predictive perfor- mance while having a significantly smaller memory footprint. This creates solutions that are equally viable, known nondominated solutions (Deb) 201T). where solution is better in both predictive performance and memory usage simultaneously. If we know the minimal predictive performance we need for task, can select the corresponding microcontroller accordingly. In Figure exemplary points are marked in orange where the accuracy is good, but the memory usage dropped. Notably, the ideal combination of the hyperparameters highly depends on the use-case. As the objectives cor- relate negatively, solely 3.37% of the solutions are dominated, leaving many possible options. One advised limit the search space to a reasonable number of nodes and trees and, firstly, increase both penalties similarly, as good solutions seem to appear more often in this space. Findings from our intensive hyperparameter grid search suggest that the penalties can be set to values greater than 20 = 1. For bigger datasets or multiclass classification values starting from 2 32 seem to work well. Thus the search space and with this also the computational demand can reduced signifi- cantly compared to the conducted experiments. However, this advise has to be taken with caution as datasets with few features or few thresholds might show other patterns.
To summarize, there is no globally optimal penalty setting as it depends on the dataset being used and the number and depth of trees allowed during training. For all datasets, we found that higher memory usage does not necessitate incline in predictive performance. Instead, the metrics mained similar until there was a considerable decrease in memory usage.
CONCLUSION & FUTURE WORK
We propose two hyperparameters and new memory layout to optimize the memory footprint of boosted decision tree ensembles. First, custom penalties within boosted decision tree training were implemented that encourage boosted tree to reuse features and thresholds and thus create smaller models. An univariate analysis has shown an effective decrease in the number of utilized values but almost unchanged performance for specific penalty values. Then, the decision tree memory layout TeaD introduced. Building upon index-based trees that enable pointer-less node sequence and global value lookup, it allows the reuse of threshold values multiple times per feature and allows storing thresholds with fewer bits, e.g. only 1 bit for boolean values. Our experiments show that we can store models with a significantly smaller memory footprint than baseline methods while maintaining the same accuracy, supporting the application of powerful boosted decision trees resource-constrained devices.
Although the linear penalizer already performed well, deeper analysis of more sophisticated pe- nalizers may reveal even better performance and thus would prove to be an interesting extension the present work. Adapting our method to reuse leaf values more effectively could also prove useful as well as the transfer to other variants of decision tree ensembles. Lastly, to further assess the effectiveness of the proposed method, its deployment to different microcontroller units would be valuable.
REPRODUCIBILITY STATEMENT
To ensure high usability and reproducibility of our findings we implemented the approach on top of the frequently used LightGBM framework. The respective implementations and code to rerun experiments can be found at:
To ensure reproducibility we refer to the release v1. C. D. Our evaluation partly relies on the Python package light gbm version 4.6.0. The references for the datasets used for the experiments can be found in Appendix while the random seeds used for splitting are documented Section 4.2
ACKNOWLEDGMENTS
This work was funded by the German Federal Ministry for the Environment, Nature Conservation, Nuclear Safety and Consumer protection, Project TinyAloT, Funding Nr. 67K132002A. Calculations for this publication were performed on the HPC cluster PALMA II of the University of Münster, subsidised by the DFG (INST 21 1/667-1).
10

---

Published as a conference paper at ICLR 2026
REFERENCES
Fouad Alkhoury, Scbastian Buschjäger, and Pascal Welke.
Splitting stump forests: tree en- Machine Learning, 114(10), Au- https:
semble compression for edge devices (extended version).
gust 2025. doi: 10. (000///00994000500666666 s 610994-025-06668
URL
Majed Alsharari, Son T. Mai, Roger Woods, and Carlos Reaño. Efficient
of gradient boosting decision trees on low-power devices. JEEE Transactions on Circuits and Systems I: Regular Papers. 72(1):241-253, January 2025. doi: 10. 10.1109/ccss.222444444888. URL
https://dof .rgg 100
2024 34465822
Jock Blackard. Covertype. UCI Machine Learning Repository, 1998. URL https://dci.org
10. N0.24432/C50K3N
Leo Breiman. Random forests. Machine Learning, 45(1):5-32, 2001.
Leo Breiman, Jerome H. Friedman, Richard A. Olshen, and Charles J. Stone. Classification And Regression Trees. Chapman and Hall/CRC, edition, 1984. doi: 00.120199781315134470 URL
org/00
Sebastian Buschjäger and Katharina Morik. Joint leaf-refinement and ensemble pruning through I regularization. Data Mining and Knowledge Discovery, 37(3):1230-121, URL https: httpss://cci.orr//1...
March 2023. doi: 10. 0007///0011800230002222 810618-023-00921
Tianqi Chen and Carlos Guestrin. Xgboost: A scalable tree boosting system. In International Con- ference on Knowledge Discovery and Data Mining (KDD). pp. 785-794, San Francisco California USA, August 2016. ACM. doi: 10. 00.1145/299967222939788
URL https:: acm. org/
doi /10/10.10 114.0..111/22999.2.. 2939785
Paulo Cortez, António Cerdeira, Fernando Almeida, Telmo Matos, and José Reis. Modeling wine preferences by data mining from physicochemical properties. Decision Support Systems, 47(4); 547-553, November 2009. doi: 10.1016/j. 2009..00..0000000..
1016/3. 2009.000000000 05.016
Kalyanmoy Deb. Mulri-objectiive Optimisation Using Evolutionary Algorithms: An Introduction,
pp. 3-34. Springer London, London, 1. doi: 10. 00010077978--08577---222 1. URL https:
//dei.org/I0 1007/ 978 85788-77289988 652-8_11
Laurens Devos, Wannes Meert, and Jesse Davis. Fast gradient boosting decision trees with bit-
level data structures. In Machine Learning and Knowledge Discovery in Databases, pp. 506-606.
Springer International Publishing, 2020. doi: 10. 10.1007/978-33 3-0-3-000--110000 35. URL https:
//doi.org/10 wwt.o////.....0999111 1007/978-220
46150-8 _5
ECML PKDD 2019.
Laurens Devos, Timo Martens, Deniz Can Oruc, Wannes Meert, Hendrik Blockeel, and Jesse Davis. Compressing tree ensembles through level-wise optimization and pruning. In Pro- ceedings of the 42nd International Conference
Machine Learning. volume 267 of Pro- ceedings of Machine Learning Research, pp. 13419-1344 13443. PMLR, 13-19 Jul 2025. URL
https:: httpps/:/ppooceeiigg..o. ptr.eeeeiiiinsmr..rss...esseeeee www.srrsssseee v2 dewos httml
Youssouf Emine, Alexandre Forel, Idriss Malek, and Thibaut Vidal. Free lunch in the forest: Functionally--identical pruning of boosted tree ensembles. Proceedings the AAAI Conference on Artificial Intelligence, 99(16):1488) 16495568885,, April 2025. doi: 00.16609/aai...31116.333 33811
URL
htttps://doi.oo www.oi.orgg/iee http::///bbb.ogg....../////.....
Zoubin Ghahramani. kin8nm.
URL https: www. wttp:://wwwwwooo...oooooom wtwp://www..o..eeeaccttteeeeeeee
1d-189
Leo Grinsztajn, Edouard Oyallon, and Gael Varoquaux. Why do tree-based models still outperform deep learning typical tabular data? In Advances in Neural Informa- tion Processing Systems, volume 35, pp. 507-520. Curran Associates, Inc 2022. URL httpss//pproccediggg.eeeeeet 0378c769 0378676924336877beee pdf
paper files/papers 202///222/22222 file/ and Benchmarks.

---

Published as a conference paper at ICLR 2026
Huaping Guo, Hongbing Liu, Ran Li, Changan Wu, Yibo Guo, and Mingliang Xu. Margin & diversity based ordering ensemble pruning. Neurocomputting, 275:237 246, 2018. doi: 10.1016/ J.neucom.201..06.06
BRLhhttss:/ /dii......//
neucom. 2017 2017.00100000 06. 052
Chirag Gupta, Arun Sai Suggala, Ankit Goyal, Harsha Vardhan Simhadri, Bhargavi Paranjape, Ashish Kumar, Saurabh Goyal, Raghavendra Udupa, Manik Varma, and Prateek Jain. Protonn: Compressed and accurate knn for resource-scaree devices. In Proceedings of the 34th Interna- tional Conference on Machine Learning, volume 70 Proceedings of Machine Learning Re- search, pp. 1331-1340. PMLR, 2017. URL BtLhhtts:: pentps://prooe http:///cccceeni...c/oe www.mlr.ppp. presss//10/ gupta 7a. html
Albert Gural and Boris Murmann. Memory-optimal direct convolutions for maximizing classifica- tion accuracy in embedded applications. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 2515-2524. URL https::/proceeste .emiiinggs.....................m wwwppesssvvv. wtt.:ppeess/suueaesee.a
PMLR, 09-15 Jun 2019.
html
Jiawei Jiang, Bin Cui, Ce Zhang, and Fangcheng Fu. Dimboost: Boosting gradient boosting decision tree to higher dimensions. In Proceedings of the 2018 International Conference on Management of Data, SIGMOD/PODS " 18, pp. 11t.//1111111111111111133 31958992
ACM, May 2018. doi: 10.1145/318371333196822
URL
Guolin Ke. Qi Meng, Thomas Finley, Taifeng Wang, Wei Chen, Weidong Ma, Qiwei Ye, and Tie-Yas Liu. LightGBM: A highly efficient gradient boosting decision tree. In Ad- vances neural information
processsinnoooooonioi processing systems (NeurIPS), volume 30. Curran Associates, Inc.,
2017. URL https::/proceeddd.nnt newrips cc/ sorrr_fii files//paerr2011/
File:/69944440007ee4666666666666 Paper
R. Kelley Pace and Ronald Barry. Sparse spatial autoregressions. Statistics & ProbabilityLeetee
33(3):291-297, 1997. doi: 10. (0.1016/SSN) 10010066/001677752299)0000000110 wtt.htsssst////ooooooooo
7016/50167-155 (96) 001 40-X
Abhishek Khanma and Sanmeet Kaur. Internet of Things (IoT), Applications and Challenges: A Comprehensive Review. Wireless Personal Communications, 11772 Septem- ber 2020. doi: 10.10077/11227--00--077444 011277-02000744--1
URL https://dci. http::////001.orr11110007777
Simon Koschel, Sebastian Buschjäger, Claudio Lucchese, and Katharina Morik. Fast inference of tree ensembles on arm devices. arXiv preprint, 2023. doi: 10:48550/ARXIV2335.08577 URL
https: www.:ii.org/////. 08579
Ashish Kumar, Saurabh Goyal, and Manik Varma. Resource-efficient machine learning in 2 kb ram for the internet of things. In Proceedings of the 34th International Conference on Machine Learning. volume 70 of Proceedings of Machine Learning Research, pp. 1935-1944. PMLR, August 2017. URL http:: htttps::/ppoceeeingg www.ingssmm......mmm..m.......w. mlr. pwwss/eesvvv.. http////akaaaaaaaataaaa
Colin Lewis- Beck and Michael Lewis-Beck. Applied regression: An introduction, volume 22. Sage publications, 2015.
Brian Liu and Rahul Mazumder. Forestprune:
Compact depth-pruned tree ensembles. Proceed- ings of The 26th International Conference on Artificial Intelligence and Statistics, volume 206 of Proceedings of Machine Learning Research, pp. 9417-9428, PMLR, 25-27 Apr 2023, URL httpps:/ppe http:///coccceein..ccmm mlr wttp://tt.p..eeee//////......
Claudio Lucchese, Franco Maria Nardini, Salvatore Orlando, Raffaele Perego, Nicola Tonellotto, and Rossano Venturini. Quickscorer: Efficient traversal of large ensembles of decision trees. In Machine Learning and Knowledge Discovery in Databases, pp. 383-387, Cham, 2017. Springer International Publishing. doi:
36. URL https: /twp://oo..ooooo org/
Philipp Mayer, Michele Magno, Thomas Brunner, and Luca Benini. Lora vs. lora: In-field evaluation and comparison for long-life lifetime sensor nodes. In International Workshop on Advances in Sensors and Interfaces (IWASI). pp. 307-311. IEEE, 2019. doi: 10.1 1 URL
https:://oi..co .or.oooorrggooo
WAST 201 0.119.771336 8791362
12

---

Published as a conference paper at ICLR 2026
Mushroom. UCI Machine Learning Repository, 1981. URL https:///oi.org///// C5959T
Feng Nan, Joseph Wang, and Venkatesh Saligrama. Pruning random forests for prediction on budget. In Advances in Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016. URL
fils/
Mike O. Ojo, Stefano Giordano, Gregorio Procissi, and Ilias N. Seitanidis. Review of Low-End, Middle-End, and High-End Iot Devices. IEEE Access, 6:70528-70554, 2018. doi: 10. 1 109/ 2CCESSS22118.8877
2011555.20110 2018 28 79615
Sven Peter, Ferran Diego, Fred A Hamprecht, and Boaz Nadler. Cost efficient gradient boost- ing. In Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017. URL htwp:////.pprreeeee.............
Natalia Ponomareva, Thomas Colthurst, Gilbert Hendry, Salem Haykal, and Soroush Radpour. Compact multi-class boosted trees. In 20/7 IEEE International Conference on Big Data (Big DataJ, pp. 47-56, 2017, doi: 10. 10 1109/Bi wwwtaaiDaaa....mm 2017 8257910
Vijay Janapa Reddi, Brian Plancher, Susan Kennedy, Laurence Moroney, Pete Warden, Anant Agarwal, Colby R. Banbury, Massimo Banzi, Matthew Bennett, Benjamin Brown, Sharad Chit- langia, Radhika Ghosal, Sarah Grafman, Rupert Jaeger, Srivatsan Krishnan, Maximilian Lam, Daniel Leiker, Cara Mann, Mark Mazumder, Dominic Pajak, Dhilan Ramaprasad, J. Evan Smith, Matthew Stewart, and Dustin Tingley. Widening access applied machine learning with tinyml. arXiv preprint, 2021.
arxiv. org abs/ / 200. 04008
Shaoqing Ren, Xudong Cao. Yichen Wei, and Jian Sun. Global refinement of random forest. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 723-730, 2015. doi: D01109/CVPR.201..7222 2015. 7298672)
URL https::/ 1109///VR...
Alen Shapiro. Chess (King- Rook vs. King-Pawn). UCI Machine Learning Repository, 1983. URL
https: //ts:///do../ ////d/..org/..24443333//3 /ttp//00024422555555533
Yu Shi, Guolin Ke, Zhuoming Chen, Shuxin Zheng, and Tie-Yan Liu. Quantized training of gradient boosting decision trees. In Advances in neural information processing systems (NeurIPS), volume 35, pp. 18822 18833. Curran Associates, Inc.,
new. 2022. URL https::/prrceedd ngs neurips cc http://eeeeeeeiieeeeeeeeeeooeeeo httpeeerrfillee/pp//////0 httl://7B.eeeeeeee6ecaaaaaaaaa11 Corpee
Hongfei Wang, Zhanfei Wu, Xiangwei Wang, Longyun Bian, and Hai Jin. Hardgbm: A framework for accurate and hardware-efficien gradient boosting machines. IEEE Transactions Computer-
Aided Design of Integrated Circuits and Systems, 42(7):2122-2135, 2023, doi: 10. 109/TCA.. 2022.3218500 URL htthtt:s::/ //dpii:///doooo http:///oooo.gg///// org/ 1109 D1A/9//CA.... 222.222.11822
Pete Warden and Daniel Situnayake. TinyML: Machine Learning with Tensorflow Lite on Arduino and Utra-Low-Power Microcontrollers. O' O'Reilly Media, Inc., 2019.
William Wolberg, Olvi Mangasarian, and Nick Street. Breast Cancer Wisconsin (Diagnostic). UCI Machine Learning Repository, 1993. URL //cctps://oi... org/10 24432/C5DDDR
Ting Ye, Hucheng Zhou, Will Y. Zou, Bin Gao, and Ruofei Zhang. Rapidscorer: Fast tree en- semble evaluation by maximizing compactness in data level parallelization. In ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pp. 941-950, London United Kingdom, July 2018 ACM. doi: 10. 10.1145/32198199222988 URL hwwphhtt:///ee acm. org/
doi/100 111.//11.1115322111111 119.14155522198912229977777 3219857
13

---

Published as a conference paper at ICLR 2026
A TRAINING COMPRESSED ENSEMBLES
Constructing an optimal tree ensemble 7 w.r. Equation 1 is computationally infeasible. There-
fore, one resorts to K boosting rounds. In each boosting round m, one considers 7m-1 == EE k= 4x
together with new tree im that is built this round (starting with To (Chen & Guestrin 2016). The new tree is chosen such that
m
Cy., + (x,))
Σ (t(x)
(4)
minimized. A common choice for the regularizer 52
L
1 (1(m)) = 7 +
2
2
where is the number of leaves and ......, E R are the associated leaf values of 4m. This penalizes trees with many leaves and large absolute leaf values. The modified regularizer
(m(mm)) (2(m)) + [P + &.
IT' JEFU
(5)
proposed in Section 3 with user-defined hyperparameters 4 E IR penalizes the use of new features and thresholds objective leads to a modified gain compared to standard boosted decision trees (Chen & Guestrin 2016). More precisely, using gradient statistics of the form
linear manner. Similar to Peter al. 2017 incorporating 2 into the
0
9: =
Clyis 2)
0z
0²
h; 22
C(yi,
T= 1(x;)
and omitting constant terms, one obtains the simplified objective
Σ Gr + 2 (Hi, + + 03 +7 4Fo++ +
EIT
IT'
(6)
JEFc
with Gs = =iE== 9: and Hs - h4 Here, I, denotes the set of training indices assigned to the j-th leaf of the current tree tm i... IG = {i 9xx,) = j}. where g Rd - (l..... .....,L) L} maps an input instance the corresponding leaf tm (i.e., tm (x) Ug(x)))
The decision tree tm is constructed greedily by iteratively splitting leaves (starting at the root) if this improves Objective (6); otherwise, the construction stops. More specifically, given a leaf associated with a set training indices, a split on feature E (1...., d} with threshold divides I into two subsets, Jr. (left leaf) and I (right leaf). The corresponding gain is then given by
1 G7, 2 H1 +X H1p +
GI
(G1)²
A(LLip)
Hy H1+ -7 -7 ---- -y6- S1E,
= A(I,, spL -S
(8)
where = if a new feature is used (and = 0 otherwise). and 8; = 1 if a new threshold used (and s, otherwise). Thus, the modified regularizer (5) introduces the additional terms -8yt and -sr corresponding to the cost of using a new feature or threshold, respectively.
14

---

Published as a conference paper at ICLR 2026
B DATASETS
An overview of the eight datasets used for experiments in Section 4 along with their statistics are presented in Table [ The binary Covertype (covtype) dataset (Blackard 1998), the California Housing (californis.hoss .oggiiggoo regression dataset (Kelley Pace & Barry 1997). the KRKPA7 (kr-vs-Ke ) dataset (Shapiro 1983) and the Breast Cancer (breast
dataset (Wolberg et al. [993) are commonly solved using boosted decision trees. The kin8nm dataset (Ghahramani, which describes robotics decision making, and the Mushroom (mushroom dataset (Mushroom, 1981j, which is for mushroom edibility classification, cover data that might be of interest for analysis on constrained edge devices.
Table 1: Datasets
Dataset
Instances
Features
Task Binary & multiclass
Covertype (Blackard_
1998
581,012
54
classification
California Housing (Kelley Pace Barry
1997
20,640
Regression
kin8nm Ghahramani
8,192
8
Regression
Mushroom Mushroom
1981
8.124
22
Binary classification
Wine Quality (Cortez et al.
2009
6,497
11
Multiclass classification
KRKPA7 kr-vs-kp (Shapiro
1983
3,196
36
Binary classification
Breast Cancer Wisconsin (diagnostic)
569
30
Binary classification
(Wolberg ct al.
1993
C EXTENDED RELATED WORK
Decision trees and decision tree ensembles, such as GBDT, have remained very popular, despite the rise of deep learning models (Grinsztajn et al.) al.] 2022). These tree-based methods are highly val- ued for their interpretability, particularly when dealing with small datasets, mixed data types, and constrained computational resources. Recent advances tree-based models have also introduced several approaches to enhance their efficiency. For instance, cost-efficient gradient boosting intro- duces mechanisms to account for feature acquisition and tree evaluation costs (Peter et al. 2017). which involves penalizing the use of new features based their cost and minimizing the number of split nodes an input traverses during inference. Other work (Ponomareva et al. 2017) presents method train compact boosted tree ensembles for multi-class classification using vector-valued trees and layer-by-layer boosting. Bonsai (Kumar et al.] (017). instead, yields a single decision tree model and reduces the model size by projecting the input data into low-dimensional subspace. Two other approaches are QuickScorer (Lucchese et al.) (017)) and its enhanced version, RapidScorer (Ye) al.) 2018), decision tree ensembles both developed for search engines, where array structures are used to reduce model size. These methods prioritize enhancing processing speed over minimizing memory footprint by summarizing features and split values for joint calculation. Recently, Koschel al. (2023) further adapted these approaches to IoT contexts, focusing on ARM CPUs prevalent in such devices. Their work involves adapting QuickScorer variants for these CPUs and applying fixed-point quantization to split nodes and leaf values, emphasizing computational enhancements over memory optimization. DimBoost (Jiang et al. 2018) made use of lower precision values dur- ing the calculation of gradient histograms in training one of their contributions to improve the performance of GBDT for high-dimensional data. Additionally, Shi et al. (2022) demonstrated that using just
three bits suffices to represent gradients GBDT training. Devos al. (2020) represent input data as well as gradients in bit-level data structures to improve the runtime of GBDT training.
The related works sketched above aim mostly at enhancing the training process, leading to improve- ments in memory and energy consumption as ancillary benefits. The notable exception are the works by Kumar et al. (2017) and Ponomareva et al. (017)). which explicitly address a memory footprint reduction the context of ressource-constrainee devices, achieving compact and effective brse-based
15

---

Published as a conference paper at ICLR 2026
models. However, the approach of Kumar et al. (2017) only considers single decision trees and con- ceptually modifies the tree building process and the underlying models. Ponomareva et al. (2017) focus on multi-class classification problems. However, the vector-values used within trees may crease the memory footprint of tree models for binary classification or for low-number multi-class problems. Additionally,
evaluation of memory consumption is not conducted directly, but rather the number of trees is used as an estimate. Specific memory consumption of different Machine Learning (ML) models and compression techniques is considered by Buschjäger Morik (2023) and (Devos et al. 2025). Their works combine ensemble pruning and update of leaves values as post-training compression methods to reduce the size of RFs and GBDTs respectively. Lossless post-training pruning of boosted ensembles is proposed by Emine et al. (2025). Liu & Mazumder 2023), on other hand, focus on pruning deep layers trees to tackle growing memory demands because of the exponential increase in the number of nodes for deeper layers. There are many other works optimizing non-decision tree-based methods for deployment on resource-constrained devices, for example, based on k-nearest neighbors Gupta al. (2017). In this work, we focus gradient boosted trees, and at minimizing the memory footprint the overall ensemble in the course of the training process. We extend the work of |Ptee al. (2017) by defining feature costs that aim at reducing the bits required to encode feature indices. We also introduce a special cost for adding new thresholds each feature and provide specialized encoding for the induced binary trees, including global threshold arrays that are shared across all individual learners.
D COMPARISON TO RANDOM FOREST
TeaD as a compression method developed for GBDT is compared to a baseline RF method for classification tasks, as well as version pruned along Guo al. (2018), as shown in Figure g This comparison is limited to a maximum of 256 trees; otherwise, the same hyperparameters as before have been used (Section Only classification results are included, since the used pruning method is not designed for regression tasks. RF methods can have a slight performance advantage for mul- ticlass problems, since boosted trees are usually trained with one ensemble per class, whereas a RF stores the class information in the nodes. An extension of our work in the future could include opti- mizing ToaD for multiclass classification, for example, based on the approach of Ponomareva et al.
2017
mushroom (hirary)
brassitenner (binary)
covlype (binary)
1,500
6.475
2.85
6.803
Levnni
Liperioo bovd
2.50
Kardia Food
8:003
TeaD Temilee
0575
0050
kn-vs-kp (binary)
(multicasss)
covbpc mull (m.ticiass)
1.0
0.4
0.50
Asouraty
0.8
0.2
0.65
0.5
200
2000
2000
Mamory (KT)
Mamorry (47)
Mernory (00)
Figure 8: Comparison of baseline LightGBM methods and ToaD to baseline RFs and RFs pruned by the method presented by Guo et al. (2018). The models were trained using 12 train-test data splits.
16

---

Published as a conference paper at ICLR 2026
E EXPERIMENTS
E RUNTIME EXPERIMENTS
For estimate for the expected runtime, we deployed ToaD-model processing the Covertype binary dataset at a memory limit of 0.5 KB. The model consists of four complete trees with depth of four. We measured 20 runs, with each run having 500 predictions. We decided to stop at 20 runs as the variance between the runs was minimal. Experiments were conducted the Seeed Xiao ESP32- S3 and the Arduino Nano 33 BLE Rev2. To ensure that programs are not further optimized, we used random numbers input. The prototypes
available at the repository Note that currently the ToaD-program is only a first prototype, and there are many options for optimization. A single prediction took 0.51 milliseconds for the ToaD-model LightGBM program, this is a slowdown by factor of ~ 5. For the ESP32-S3, a single prediction took 0.14 milliseconds, with respective slowdown in contrast to LightGBM of factor of 8. Those findings should be read as an outlook for future work to incorporate optimization techniques close the runtime gap. As already stressed in the main paper, the observed latency degradation is not significant factor in real-world deployments. At below millisecond inference time for ToaD, the overall latency and energy consumption of real-world use cases is dominated by the device measuring the input data and potentially transmitting the results.
the Arduino Nano. In contrast to the
Hardware
Average Prediction Runtime (us)
ToaD
LightGBM
XIAO ESP32S3
137.08
17.63
Arduino Nano 33 BLE
512.89
102.16
Table 2: Runtime for one inference run for the Covertype binary dataset with four trees, each with depth of four.
E.2 UNIVARIATE SENSITIVITY ANALYSIS
Influence feature penalty & and threshold penalty & on the number of thresholds and the number of features, for different hyperparamter settings are displayed in the following figures. The respective top row shows the influence of i on the number features and the performance when & = O. The respective top row shows the influence of the number of thresholds and the performance when
i = O. Additionally the reuse factor ReF is displayed as described in Section 4.3
We observe similar patterns in the evolution of used features and thresholds and the correspond- ing performance as described in Section 4.
Pomiaa routing
knntrm
RCAS
Dilaet)
CIstaDe mul
facorehinely
Fastar Fonals
Farors hendly
Ferals
Thannf
Theped
Trensct Fiaats
Theesvid Perily
Phidans
Figure 9: mar masaiterations 4, max-_eeth
latency
17

---

Published as a conference paper at ICLR 2026
pegresderr
OTN Eclan)
Park Meceeer
phihh 2
و 2
Itaendd Posdly
Fonnty
#Thaae DI
Figure 10: iterations max depth =
jesmedder)
Imuricare
Feais Fraals
Feater beadly
Festant Farsty
Fee Friily
Teale Fand
Porkir heaals
Festine Seaty
2525 Thrnnd Farey
Toussod hasily
Treanii Perey
Toursd
Thapu Paaaly
Tonasel heatty
Thruted Feraty
Plezar
PARK
Figure 11: itteratonnnsssso max depth
Pomra rourthg pogtccalen
coutyce
Dreastzarcer
mutrroom
coutyoe mull
(nggrtaber
Saain Fasty
Festus Aasaly
Festar Faraty
Facur Iriilt
Feaiis hanel
Factur Iniaat
Festire herkey
1389
Thadted Prxids
Pore
Satter
Figure 12: mar iterations 64, max depth =
roupiing pegrtsadort
cislim
Prenstrateer
Ohyyoo muli
34%
Naltun Novtty
Facus hrudy
Hodls hortly
LSCE
Teeskei headly
Brealty
Thind Rrady
Thavied Pradss
Pork
Busefftee
Figure 13: mer mer.iterations 64, max 4
18

---

Published as a conference paper at ICLR 2026
Inggraalort
Iamaary
Greeyl
(oitury)
Podtdt Notty
LOOK
Aete
2003
1009
plight y 3
27.2 Paaty
2 Paaay
haadty
Praty
Figure 14: max iterations 64, mar depth =
himia routing rrggessert
sp
mustmom
wite
coubpe muhh Indielas
pegieawent
Aodax Breel
Pestec Foraty
Bocken hxdy
269
EEX
3d
1000
120
The Perdly
Figure 15: mar itteraiion 1024, max deeth
fenia Fousing
krrmm
broastcarAr
mustroom
cospac muk:
Farui
13
123
2- Trenvifeerty
Thrand Fires
Trannc
Traitidferaty
Patre
Catte
Figure 16: mar ileralions 1024, max depth
forda housing
Iroastcancer
mushrom
HAP 180
223
Figure 17: max interatiinnssss = 1024, max max-depth =
19

---

Published as a conference paper at ICLR 2026
E.3 MULTIVARIATE SENSITIVITY ANALYSIS
In the following figures the influence of i and on the needed memory (KB) on the top row and the depicted for different hyperpa-
representative metric (accuracy It score) the bottom rameter settings.
Similarly as depicted in Figure 7 and described in Section 4.4 we can find useful penalty combi- nations that provide useful trade-off between a small decrease in performance but a significant decrease memory consumption for most of the given examples.
calferma housing Eragnoserro
Indin
erve kp
FiL Bemway!
coutize
34.
20
2: Namky
24
24
20
Theared heaety
Tham Fensly
Figure 18: max iterations maæ depth 2
Orggnaseen
Dugeitor ond
denary!
Gamony:
Oriil csoo)
24
Figure 19: max iaattttttaaiion maz depth 4
(alfoma Joacing
anavdcarcer
mudhrom
costure muli
3
Tesnoo Namby
Twenrd heaets
Thees Par
Figure 20: max iterations 4, max depth 8
calforii housing Craynosinn
Despesso
mraalcancar (ERarn
tevent
Bamanry:
Gruul
cartpe 1IMildSs
24
24 2 M 20
24
20
2/4
2
Figure 21: mar iterations 64, max decth
20

---

Published as a conference paper at ICLR 2026
calforma Josokng
bravdlaaccar
25
20 Trratec Harr
Figure max iterations 64, max depth
Crog weden)
Tegreste
Dirany
UIART
Figure 23: mar man.iteeationss = 64, mar depth = 8
calfoma Freeiin
Valin
Brnw Sranowr
(nubit
23.
14 TTaaaoieraay
24 Tomance Po
12 Traatacc Parety
Waak
hearty
Figure 24: max itteaaioon 1024, max depth
Crig weden))
Pegrest on!
(thany)
Dinany
483
Figure 25: max. max itteaaions = 1024, maz_depth 4
F LARGE LANGUAGE MODEL USAGE
This manuscript has undergone sentence-level improvements using Large Language Models (LLMs) to enhance clarity and readability. However, all scientific ideas, methods, results and conclusions the exclusive work the authors.
21


Reviews:
[{"review_id": "d1NBpoycU0", "reviewer": "Reviewer_GwkK", "summary": "In this article, the authors propose Trees on a Diet (ToaD), a training‑time compression framework for Gradient-Boosted Decision Tree (GBDT) ensembles, targeting microcontrollers and, more generally, resource-constrained edge/embedded devices.\nThe core ideas are: *i)* adding linear regularizers that penalize the introduction of new features and new thresholds across the ensemble to encourage reuse during tree growth, and *ii)* deploying a pointer‑less bit‑wise memory layout with global lookup tables for feature thresholds and global leaf values shared across all trees.\nThe results show that ToaD matches the competitor's performance, reporting 4 to 16 times lower memory usage for the same accuracy in the most relevant memory range (≤128 KB).", "questions": "The authors should:\n1) Provide inference latency and energy consumption (per prediction) on representative MCUs (*e.g.*, the mentioned ARM Cortex‑M4 @ 48 MHz) for ToaD versus baselines.\n2) Clarify the reuse factor formula to align with the intended interpretation.\n3) Report memory results under a unified layout, or at least discuss the potential advantages of ToaD against baseline models.\n4) Report mean±std for accuracy at each memory budget, and compare against other relevant presented works only mentioned in the state-of-the-art.", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "The work tackles a concrete real-world problem: DTs on microcontrollers, where RAM and flash budgets are very limited.\n\nThe article is well-written, structured, and easy to follow.\n\nThe proposed method is described in sufficient detail.\nSpecifically, the introduction of ensemble-level penalties using features and thresholds is a simple yet effective idea to induce parameter reuse, which complements post-training pruning/quantization.\nFurthermore, the design choice to store the threshold bit-width and numeric type per feature provides a flexible precision/size trade-off.", "weaknesses": "The primary motivation for this work is the deployment of GBDT on resource-constrained devices, where memory is a critical constraint, as well as latency (and energy consumption).\nThe authors provide results of memory savings, but do not present any experimental results on inference speed (and energy consumption).\nWithout this analysis, the practical utility of ToaD for real-time edge applications remains unproven.\n\nThe authors state that the $RF$ is “the ratio between the global number of values and the sum of the nodes and leaves” (line 371).\nThus, if values are reused effectively, the number of global values becomes smaller, while the number of nodes and leaves remains fixed; therefore, a good reuse would produce $RF<1$.\nAt line 374, the interpretation in the text says the opposite, implying that $RF$ should be (#nodes + #leaves)/(#global values), *i.e.*, the inverse of the statement above.\n\nMemory for baselines is computed under a simplified node model that includes two child pointers, whereas ToaD benefits from a pointer‑less encoding and global sharing.\nThis risks giving ToaD an advantage in the comparison.\n\nExperiments use a single 80/20 split per dataset with large sweeps and report the best points within memory limits; however, no statistical significance values are presented.\n\nThe authors cite several other relevant works on tree compression and optimization (*e.g.*, Koschel et al., 2023, and Buschjäger & Morik, 2023) in their related work section, but do not include them in the experiments.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "moCgosojJR", "reviewer": "Reviewer_YmzG", "summary": "This paper introduces Trees on a Diet (ToaD), a method for compressing GBDT for resource-constrained devices. It employs a regularization strategy that encourages the reuse of features and thresholds during training, coupled with a specialized, bit-wise memory layout. This layout uses global lookup tables and a pointer-less array representation to minimize storage. Evaluated on eight tabular datasets, ToaD compresses models that are 4–16× smaller than baseline LightGBM while maintaining comparable accuracy under tight memory constraints.", "questions": "1. The search over 32,076 configurations per dataset is computationally intensive. Do you have any insights or heuristics for navigating the hyperparameter more efficiently in practice?\n2. For larger models that must reside in main memory (or SSD) and are evaluated on systems with hierarchical caches, could the non-sequential, lookup-heavy memory access pattern of your method lead to frequent cache misses or I/O bottlenecks compared to the more sequential access of standard array-based tree representations?", "limitations": "", "rating": 6, "confidence": 2, "soundness": 3, "presentation": 2, "contribution": 4, "strengths": "1. The work enables complex models like GBDTs to run on severely memory-constrained microcontrollers.\n2. The proposed pointer-less array-based memory layout is highly suitable for microcontroller deployment, minimizing memory footprint and avoiding inefficient pointer chasing.\n3. The method is orthogonal to many existing compressions like pruning and quantization, and easy to integrate into existing work\n4. The experimental evaluation is comprehensive and sound", "weaknesses": "1. Potential inference latency overhead. The decoding process involving bit-level manipulations and lookups in global arrays may inherently more computationally expensive than the direct pointer-based traversal used in standard implementations. The paper would be significantly strengthened by an end-to-end latency evaluation.\n2. Linear penalty is not motivated theoretically (e.g., from a Bayesian perspective) or empirically against other potential forms. Would a logarithmic penalty, which might better model diminishing costs, be more effective? \n3. Several figures (e.g., Figure 6)  is so small that makes the text are hard to read. Furthermore, in Figure 5, the label is partially covered.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "nWcjPSG1IA", "reviewer": "Reviewer_BpWP", "summary": "This research introduces a novel compression scheme tailored for boosted decision tree ensembles to address the challenge of deploying machine learning models on compute-constrained IoT devices. The approach focuses on training compact models by strategically encouraging the reuse of features and thresholds. Experimental results demonstrate a substantial memory footprint reduction of 4–16x compared to standard LightGBM models without compromising performance. This optimization is crucial for enabling autonomous, low-power IoT applications such as remote monitoring, edge analytics, and real-time decision-making in isolated or energy-limited environments.", "questions": "What are some real-life scenarios where one will need to do training on MCUs?", "limitations": "", "rating": 4, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "Penalizing the use of new features/thresholds encourages reuse across trees. The idea of feature reuse and threshold reuse is interesting and simple yet useful for sustainable ML. Introduction of a new loss function. \n\nThe work is very useful for doing efficient ML on resource-constrained devices.  \n\nGood sensitivity analysis. \n\nI found the writing to be decent, and the paper is well structured. \n\nThe performance gains with minimal memory consumption compared to SOTA methods.", "weaknesses": "The part on memory layout based on encoding the information in a bit-wise manner is not novel. \n\nNo actual implementation on MCUs, which makes this a purely algorithmic work. A bit more analysis, including power consumption and energy efficiency, is required. \n\nDomains requiring distinct rules (e.g., heterogeneous datasets) do not allow threshold reuse without performance loss.\n\nThe idea is good, but the utility of it is limited. For example, it does not make sense to train ML models on tiny MCU devices with 32 KB of RAM. The authors should motivate the real use case scenarios where their proposed method will be useful in the real world.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "GslKxpLgpu", "reviewer": "Reviewer_gDno", "summary": "This paper introduces compressed boosted decision trees for constrained devices. The authors reuse values across thresholds, leaves, etc. and create a compact memory layout. The results indicate that the proposed methods are competitive in accuracy while being significantly better in comression.", "questions": "1. Can you expand related work to include more methods for optimizing tree-based methods on constrained devices?\n2. Can you compare your work empirically to those papers?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "1. The paper is clear to read\n2. The motivation and the constraints specified as per use cases and practical designs pique the interest\n3. The proposed method is well-described and the method appears very intuitive\n4. The results and analysis are rigorous and show good performance", "weaknesses": "1. I am not from this exact area but I am a bit surprised if there aer not more related works. Neural network pruning, quantization and deployment on edge devices is common. But, perhaps even for tree-based methods there are more such related work. Atleast, a couple of examples that come to my mind.\n\n• ProtoNN: Compressed and Accurate kNN for Resource-scarce Devices\nChirag Gupta, Arun Sai Suggala, Ankit Goyal, Harsha Vardhan Simhadri, Bhargavi Paranjape, Ashish Kumar,\nSaurabh Goyal, Raghavendra Udupa, Manik Varma and Prateek Jain\nInternational Conference on Machine Learning (ICML), 2017\n\n• Resource-efficient Machine Learning in 2 KB RAM for the Internet of Things\nAshish Kumar, Saurabh Goyal and Manik Varma\nInternational Conference on Machine Learning (ICML), 2017\n\n\n2. Continuation to above -- I think the absence of more baselines esp. in optimized tree implementations is a weakness.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)