P RETRAIN THEN F INETUNE : G ETTING THE M OST FROM Y OUR L ABELED D ATASET IN T ABULAR D EEP L EARNING
Anonymous authors
Paper under double-blind review
A BSTRACT
Similarly to computer vision and NLP, deep learning models for tabular data can benefit from pretraining, which is not the case for traditional ML models, such as gradient boosted decision trees (GBDT).
Although the pretraining techniques for tabular data are actively studied, the existing works mostly focus on the unsupervised pretraining, implying the access to a large amount of unlabeled data in addition to the labeled target dataset. By contrast, pretraining in the fully supervised setting, when the available data is fully labeled and directly represents the downstream tabular task, receives significantly less attention. Moreover, the existing works on pretraining typically consider only the simplest MLP architectures and do not cover the recently proposed tabular models.
In this work, we aim to identify the best practices for pretraining in tabular DL that can be universally applied to different datasets and architectures in the fully supervised setting.
Among our findings, we show that using the object target labels during the pretraining stage is beneficial for the downstream performance and advocate several target-aware pretraining objectives.
Overall, our experiments demonstrate that properly performed pretraining significantly increases the performance of tabular DL models on fully supervised problems.
I NTRODUCTION
Tabular problems are ubiquitous in industrial ML applications, which include data described by a set of heterogeneous features, such as learning-to-rank, click-through rate prediction, credit scoring, and many others.
Despite the current dominance of deep learning models in the ML literature, for tabular problems, the “old-school” decision tree ensembles (e.g., GBDT) are often the top choice for practitioners.
Only recently, several works have proposed the deep models that challenge the supremacy of GBDT in the tabular domain (Arik & Pfister, 2020; Gorishniy et al., 2021; 2022) and suggest that the question “tabular DL or GBDT” is yet to be answered.
An important advantage of deep models over GBDT is that they can potentially achieve higher performance via pretraining their parameters with a properly designed objective.
These pretrained parameters, then, serve as a better than random initialization for subsequent finetuning for downstream tasks.
For computer vision and NLP domains, pretraining is a de facto standard and is shown to be necessary for the state-of-the-art performance (He et al., 2021; Devlin et al., 2019).
For tabular problems such a consensus is yet to be achieved as well as the best practices of tabular pretraining are to be established.
While a large number of prior works address the pretraining of tabular DL models (Yoon et al., 2020; Bahri et al., 2022; Ucar et al., 2021; Darabi et al., 2021), it is challenging to make reliable conclusions about pretraining efficacy in tabular DL from the literature since experimental setups vary significantly.
Moreover, most evaluation protocols assume the unlabeled data is abundant and only use a small subset of labels from each dataset during finetuning for evaluation – demonstrating pretraining efficacy, but somewhat limiting the performance of supervised baselines on these datasets.
Such protocols of “unsupervised pretraining” are common in vision or
NLP domains, where huge “extra” data is available on the Internet.
In contrast, in our work, we focus on the setup with fully labeled tabular datasets to understand if pretraining helps tabular DL in a fully supervised setting and compare pretraining methods to the strong supervised baselines.
We argue that this setup is reasonable in practice, since for many tabular problems there is no publicly available relevant data to pretrain on.
In this setup, we perform a systematic experimental evaluation of several pretraining objectives, identify the superior ones, and describe the practical details of how to perform tabular pretraining optimally.
Our main findings, which are important for practitioners, are summarized below:
• Pretraining provides substantial gains over well-tuned supervised baselines in the fully supervised setup.
• Simple self-prediction
based pretraining objectives are comparable to the objective based on contrastive learning.
To the best of our knowledge, this behavior was not reported before in tabular DL.
• The object labels can be exploited for more effective pretraining.
In particular, we describe several “target-aware” objectives and demonstrate that they often outperform their “unsupervised” counterparts.
• The pretraining provides the most noticeable improvements for the vanilla MLP architecture.
In particular, their performance after pretraining becomes comparable to the state-ofthe-art models trained from scratch, which is important for practitioners, who are interested in simple and efficient solutions.
• The ensembling of pretrained models is beneficial.
It indicates that the pretraining stage does not significantly decrease the diversity of the models, despite the fact that all the models are initialized by the same set of parameters.
Overall, our work provides a set of recipes for practitioners interested in tabular pretraining, which results in higher performance for most of the tasks.
The code of our experiments is available online.
R ELATED W ORK
Here we briefly review the lines of research that are relevant to our study.
Status quo in tabular DL.
A plethora of recent works have proposed a large number of deep models for tabular data (Klambauer et al., 2017; Popov et al., 2020; Arik & Pfister, 2020; Song et al., 2019; Wang et al., 2017; Badirli et al., 2020; Hazimeh et al., 2020; Huang et al., 2020; Gorishniy et al., 2021; Kossen et al., 2021).
Several systematic studies, however, reveal that these models typically do not consistently outperform the decision tree ensembles, such as GBDT (Gradient Boosting
Decision Tree)
(Chen & Guestrin, 2016; Prokhorenkova et al., 2018; Ke et al., 2017), which are typically the top-choice in various ML competitions (Gorishniy et al., 2021; Shwartz-Ziv & Armon, 2021).
Additionally, several works have shown that the existing sophisticated architectures are not consistently superior to properly tuned simple models, such as MLP and ResNet (Gorishniy et al., 2021; Kadra et al., 2021).
Finally, the recent work (Gorishniy et al., 2022) has highlighted that the appropriate embeddings of numerical features in the high-dimensional space are universally beneficial for different architectures.
In our work, we experiment with pretraining of both traditional MLP-like models and advanced embedding-based models proposed in Gorishniy et al.
Pretraining in deep learning.
For domains with structured data, like natural images or texts, pretraining is currently an established stage in the typical pipelines, which leads to higher general performance and better model robustness (He et al., 2021;
Devlin et al., 2019).
Pretraining with the auto-encoding objective was also previously studied as a regularization strategy helping in the optimization process without large scale pretraining datasets (Erhan et al., 2010; El-Nouby et al., 2021; Krishna et al., 2022).
During the last years, several families of successful pretraining methods have been developed.
An impactful line of research on pretraining is based on the paradigm of contrastive learning, which effectively enforces the invariance of the learned representations to the human-specified augmentations (Chen et al., 2020;
He et al., 2020).
Another line of methods exploits the idea of self-prediction, i.e., these methods require the model to predict certain parts of the input given the remaining parts (He et al., 2021;
Devlin et al., 2019).
In the vision community, the self-prediction based methods are shown to be superior to the methods that use contrastive learning objectives (He et al., 2021).
In our experiments, we demonstrate that self-prediction based objectives are comparable to the contrastive learning ones on tabular data, while being much simpler.
Pretraining for the tabular domain.
Numerous pretraining methods were recently proposed in several recent works on tabular DL (Arik & Pfister, 2020; Yoon et al., 2020;
Darabi et al., 2021;
Ucar et al., 2021; Somepalli et al., 2021; Kossen et al., 2021; Padhi et al., 2021).
However, most of these works do not focus on the pretraining objective per se and typically introduce it as a component of their tabular DL pipeline.
Moreover, the experimental setup varies significantly between methods.
Therefore, it is difficult to extract conclusive evidence about pretraining effectiveness from the literature.
To the best of our knowledge, there is only one systematic study on the tabular pretraining (Bahri et al., 2022), but its experimental evaluation is performed only with the simplest MLP models, and we found that the superiority of the contrastive pretraining, reported in Bahri et al.
(2022), does not hold for tuned models in our setup, where contrastive objective is comparable to the simpler self-prediction objectives.
R EVISITING PRETRAINING OBJECTIVES
In this section, we evaluate the typical pretraining objectives under the unified experimental setup on the number of datasets from the literature on tabular DL.
Our goal is to answer whether pretraining generally provides significant benefits over tuned models trained from scratch and to identify the pretraining objectives that lead to the best downstream task performance.
3. E XPERIMENTAL SETUP
We mostly follow the experimental setup from Gorishniy et al.
and describe its main details here for completeness.
Notation.
Each tabular dataset ( X , Y ) is represented by a set of pairs { ( x i , y i ) } ni =1 , where x i = ( x 1 i , . . .
, x mi ) ∈
X are the object’s features (both numerical and categorical) and y i ∈ Y is the target variable.
The downstream task is either regression Y
= R or classification Y
= { 1 , . . .
, k } .
Each model has the backbone f ( x | θ ) that is followed by two separate heads: a pretraining head h
( z | µ ) and a downstream task head g
( z | λ ) , with learnable parameters θ, µ, λ respectively, and z = f ( x | θ ) denotes the output of the backbone for an input object x .
Datasets.
We evaluate the pretraining methods on a curated set of eleven middle to large scale datasets used in prior literature on tabular deep learning.
The benchmark is biased towards tasks, where tuned MLP models were shown to be inferior to GBDT (Gorishniy et al., 2021) since we aim to understand if pretraining can help the deep models to beat the “shallow” ones.
The datasets represent a diverse set of tabular data problems with classification and regression targets.
The main dataset properties are summarized in Table 1.
We report ROC-AUC for all binary classification datasets, accuracy for multi-class classification datasets and RMSE for regression datasets, with OT being the one exception, where we report logloss, as it was used as a default metric in the corresponding Kaggle competition.
We use the quantiletransform from the Scikit-learn library (Pedregosa et al., 2011) to preprocess the numerical features for all datasets except OT, where the absence of such transformation was shown to be superior (Gorishniy et al., 2022).
Additional information about the datasets is provided in Appendix A. [Table]
Models.
We use MLP as a simple deep baseline to compare and ablate the methods.
Our implementation of MLP exactly follows Gorishniy et al.
(2021), the model is regularized by dropout and weight decay.
As more advanced deep models, we evaluate MLP equipped with numerical feature embeddings, specifically, target-aware piecewise linear encoding (MLP-T-LR) and embeddings with periodic activations (MLP-PLR) from Gorishniy et al.
These models represent the current state-of-the-art solution for tabular DL (Gorishniy et al., 2022), and are of interest as most prior work on pretraining in tabular DL focus on pretraining with the simplest MLP models in evaluation.
The implementation of models with numerical embeddings follows Gorishniy et al.
We use
AdamW (Loshchilov & Hutter, 2019) optimizer, do not use learning rate schedules and fix batch sizes for each dataset based on the dataset size (see Appendix A).
Pretraining is always performed directly on the target dataset and does not exploit additional data.
The learning process thus comprises two stages.
On the first stage, the model parameters are optimized w.r.t.
the pretraining objective.
On the second stage, the model is initialized with the pretrained weights and finetuned on the downstream classification or regression task.
We focus on the fully-supervised setup, i.e., assume that target labels are provided for all dataset objects.
Typically, pretraining stage involves the input corruption: for instance, to generate positive pairs in contrastivelike objectives or to corrupt the input for reconstruction in self-prediction based objectives.
We use random feature resampling as a proven simple baseline for input corruption in tabular data (Bahri et al., 2022; Yoon et al., 2020), we tune the corruption probability in all experiments.
Learning rate and weight decay are shared between the two stages (see Table 15 for the ablation).
We fix the maximum number of pretraining iterations for each dataset at 100 k .
On every 10 k -th iteration, we compute the value of the pretraining loss using the hold-out validation objects for early-stopping on large-scale WE, CO and MI datasets.
On other datasets we directly finetune the current model every 10 k -th iteration and perform early-stopping based on the target metric after finetuning (we do not observe much difference between early stopping by loss or by target metric, see Table 16).
Hyperparameters & Evaluation.
Hyperparameter tuning is crucial for a fair comparison, therefore, we use Optuna (Akiba et al., 2019) to optimize the model and pretraining hyperparameters for each method on each dataset.
We use the validation subset of each dataset for hyperparameter tuning.
The exact search spaces for the hyperparameters of each method are provided in Appendix B.
We run the tuned configuration of each pretraining method with 15 random seeds and report the average metric on the test splits.
When comparing to GBDT, we obtain three ensembles by splitting the fifteen single model predictions into three disjoint subsets of five models and averaging predictions within each subset.
Then, we report the average metric over the three ensembles.
3. C OMPARING PRETRAINING OBJECTIVES
Here we compare the contrastive learning and self-prediction objectives from prior work in the described setup.
For contrastive learning, we follow the method described in Bahri et al.
(2022): use
InfoNCE loss, consider corrupted inputs ˆ x as positives for x and the rest of the batch as negatives.
For self-prediction methods, we evaluate two objectives: the first one is the reconstruction of the original x , given the corrupted input ˆ x (the reconstruction loss is computed for all columns), the second one is the binary mask prediction, where the objective is to predict the mask vector m indicating the corrupted columns from the corrupted input ˆ x .
The results of the comparison are in Table 2.
We summarize our key findings below.
Contrastive is not superior.
Both the reconstruction and the mask prediction objectives are preferable to the contrastive objective.
The two self-prediction objectives have the advantage of being conceptually simpler, and easier to implement, while also being less resource-intensive (no need for the second view of augmented examples in each batch, simpler loss function).
We thus recommend the self-prediction based objectives as a practical solution for pretraining in tabular DL.
Pretraining is beneficial for the state-of-the-art models.
Models with the numerical feature embeddings also benefit from pretraining with either reconstruction or mask prediction demonstrating the top performance on the downstream task.
However, the improvement is typically less noticeable compared to the vanilla MLPs.
There is no universal solution between self-prediction objectives.
We observe that for some datasets the reconstruction objective outperforms the mask prediction (OT, WE, CO, MI), while [Table] on others the mask prediction is better (GE, CH, HI, AD).
We also note that the mask prediction objective sometimes leads to unexpected performance drops for models with numerical embeddings (WE, MI), we do not observe significant performance drops for the reconstruction objective.
The main takeaway: simple pretraining strategies based on self-prediction lead to significant improvements in the downstream accuracy compared to the tuned supervised baselines learned from scratch across different tabular DL models and datasets.
In practice, we recommend trying both reconstruction and mask prediction as tabular pretraining baselines, as either one might show superior performance depending on the dataset being used.
T ARGET - AWARE PRETRAINING OBJECTIVES
In this section, we show that exploiting the target variables during the pretraining stage can further increase the downstream performance.
Specifically, we evaluate several strategies to leverage information about targets during pretraining, identify the best ones and compare them to GBDT.
Below we describe a list of target-aware pretraining objectives that we investigate.
Supervised loss with augmentations .
A straightforward way to incorporate the target variable into the pretraining is by using the input corruption as an augmentation for the standard supervised learning objective.
An important difference of this baseline in our setup to the one in Bahri et al.
(2022) is that we treat learning on corrupted samples as a pretraining stage and finetune the entire model on the full uncorrupted dataset afterwards (we ablate this in subsection 5.3).
Supervised loss with augmentations + self-prediction .
We evaluate a natural extension to the above baseline: a combination of the supervised objective with the unsupervised self-prediction.
Note, that during the pretraining stage both losses are calculated on corrupted inputs, while the finetuning is performed on the non-corrupted dataset.
For the self-prediction objectives we evaluate both the reconstruction and the mask prediction.
We use different prediction heads for supervised and self-prediction objectives.
We sum supervised and self-prediction losses with equal weights.
Target-aware pretraining .
An alternative to the approaches described above is the modification of the pretraining task itself.
An example of this approach is supervised contrastive learning (Khosla et al., 2020), where the target variable is used to sample positive and negative examples.
We introduce the target variable into the self-prediction based objectives with two modifications.
First, we condition the mask prediction or the reconstruction head on the original input’s target by concatenating the hidden representation from the backbone network z
= f
(ˆ x ) with the target variable representation before passing it to the pretraining head to obtain predictions p =
[Table]
h ( concat [ z, y ]) .
For classification datasets we y with one-hot-encoding, for regression targets we use the scaling.
Second, we change the input corruption scheme by sampling the replacement from the feature target conditional distribution where a target is different to the original.
Intuitively, corrupting the input object x in the direction of the target different to the original makes the pretraining task more correlated with the downstream target prediction.
Concretely, given an object-target pair ( x i , y i ) , we sample a new target ˆ y i from a uniform distribution over the set { y | y ̸
= y i } 2 , then each feature x j is replaced with a sample from the p ( x j | ˆ y i ) distribution, instead of p ( x j ) .
4. C OMPARING TARGET - AWARE OBJECTIVES
Here we compare the strategies of incorporating the target variable into pretraining.
The results of the comparison are in Table 3.
Our key findings are formulated below.
Supervised loss with augmentations is another strong baseline for MLP .
Pretraining with the supervised loss on corrupted data consistently improves over supervised training from scratch for the
MLP.
This objective is a strong baseline along with the self-prediction based objectives.
However, for models with numerical embeddings the supervised objective with corruptions is less consistent and sometimes is inferior to training from scratch, thus for these models we recommend the selfprediction objectives alone as baselines. [Table]
Target-aware objectives demonstrate the best performance .
Both the supervised loss with selfprediction and modified self-prediction objectives improve over the unsupervised pretraining baselines across datasets and model architectures.
For the objective with the combination of supervised and self-prediction losses the variation with the reconstruction loss is the most consistent across models and dataset with no performance drops below the pretraining-free baseline.
The variant with mask prediction shows similar performance and stability for the MLP, but is not as good as reconstruction for models with numerical embeddings.
For the target-aware self-prediction objectives, the modified mask prediction delivers significant improvements over its unsupervised counterpart.
Modified reconstruction objective, however, does not improve over its unsupervised counterpart.
Main takeaways : Target-aware objectives help further increase the downstream performance, improving upon their unsupervised counterparts.
For the reconstruction based self-prediction baseline the addition of the supervised loss is most beneficial (”rec + sup” from Table 4), for the mask prediction objective it’s target-aware modification provides more improvements (”mask + target” from
Table 4).
A simple MLP model pretrained with those ”target-aware” objectives often reaches or surpasses complex models with numerical embeddings trained from scratch.
In practice, we recommend first trying the baseline pretraining objectives (”rec”, ”mask”, ”sup” from Table 4), choosing the suitable baseline for the dataset and improving it accordingly: supervised loss for the reconstruction and target-aware modification for the mask prediction.
4. C OMPARISON TO GBDT
Here we compare MLPs and MLPs with numerical feature embeddings pretrained with the supervised loss with reconstruction and the target-aware mask prediction objectives to the GBDTs.
Table 4 shows the results of the comparison.
We observe that both pretraining with target aware objectives and using numerical feature embeddings consistently improve the performance of the simple MLP backbone.
In particular, MLP coupled with target aware pretraining starts to outperform GBDT on 4 datasets (GE, CA, OT, HI).
Combined with numerical feature embeddings, pretraining improves MLP performance further, making it superior to GBDT on the majority of the datasets, with two exceptions in WE and MI.
A NALYSIS 5. I NVESTIGATING THE PROPERTIES OF PRETRAINED MODELS
In this section, we provide a possible explanation of why the incorporation of the target variable into pretraining can lead to better downstream task performance.
We do this through the experiments on [Figure] The trained models decently capture the information about all the features, while the randomly initialized models capture the most informative features and suppress the others. [Equation]
[Table]
[Figure] [Table] the controllable synthetic data. Here we describe the properties and the generation process of the data and our observations on the differences of the pretraining schemes.
We follow the synthetics generation protocol described in Gorishniy et al.
(2021) with a modification that allows for the manual control of the feature importance for the particular prediction task.
Concretely, we generate the objects features { x i } ni =1 as samples from the multivariate Gaussian distribution with zero mean and covariance matrix Σ with identical diagonal and a constant c = 0 .
5 everywhere else.
Additionally, we sample a vector p ∈ R m from the Dirichlet distribution p ∼ Dir (1 m ) and let p define the influence of the objects features on the target by sampling features for tree splits with probabilities defined by this vector.
Intuitively if a particular feature is often used for splitting in the nodes of a decision tree, it would have more influence on the target variable.
Indeed, we find the feature importances 3 correlate well with the predefined vector p .
For more details on the synthetic dataset construction see Appendix C.
For each generated dataset, we then check whether the finetuned models capture the information about object features in their representations.
Specifically, we train an MLP to predict the value of the i -th object feature given the frozen embeddings produced by a finetuned network initialized from (a) random initialization, (b) mask prediction pretraining, (c) target-aware mask prediction pretraining.
The separate MLP is used for each feature and the RMSE learning objective is used.
Then we report the RMSE on the test set for all features i ∈ [0 , m ] along with their importance rank in the dataset on Figure 1 (we use CatBoost feature importances).
Here, the lower ranks correspond to the more important features.
Figure 1 reveals that the target-aware pretraining enables the model to capture more information about the informative features compared to the “unsupervised” pretraining and, especially, to the learning from scratch.
The latter one successfully captures the most informative feature from the training data, while suppressing the less important, but still significant features.
We conjecture that this is the source of superiority of the target-aware pretraining.
5. E FFICIENT ENSEMBLING
Here we show, that it is possible to construct ensembles from one pretraining checkpoint (pretrained with the target conditioned mask prediction objective).
To this end, we run finetuning withdifferent random seeds starting from the one pretrained checkpoint.
Table 5 shows the results.
Both ensembling the models from a shared pretrain checkpoint and ensembling multiple independent pretraining runs produces strong ensembles, which shows that it is sufficient to pretrain once and create ensembles by several independent finetuning processes.
This is important in practice since finetuninig is typically cheaper (i.e. requires fewer iterations), and still is able to produce diverse models from the one pretraining checkpoint for ensembles of comparable quality.
[Table]
[Table]
5. O N IMPORTANCE OF FINETUNING ON CLEAN DATA
Here we show, that the second stage of finetuning the model on the entire dataset without input corruption is often necessary for the best downstream performance.
To this end we compare finetuning the models on clean data with using models right after pretraining for two objectives: supervised loss and supervised loss with the reconstruction objective.
Results are shown in Table 6.
Across all datasets for both methods finetuning on uncorrupted data with the supervised loss proves to be essential for the best performance.
Sometimes excluding the second finetuning stage degrades the performance below the tuned supervised baseline of training from scratch.
5. D OES PRETRAINING REQUIRE MORE COMPUTE ?
In this section we investigate how much more time is spent on pretraining, compared to training the models from scratch.
We run pretraining with ”rec + sup” objective with 50k and 150k pretraining iterations thresholds (early-stopping, in theory, could make 150k iterations equivalent to the 50k, but in practice it was not the case).
We report downstream performance along with average time spent to pretrain and finetune a model in Table 7 (we also add CatBoost training times to the table).
Pretraining often requires by an order of magnitude more compute, it is especially apparent on smaller scale datasets like GE, CH, CA, HO, OT, HI, AD.
However, the absolute time spent on pretraining is still acceptable, as the original training from scratch takes seconds on small datasets.
Generally, the more iterations you use for pretraining, the better downstream quality you get.
C ONCLUSION
In this work, we have systematically evaluated typical pretraining objectives for tabular deep learning.
We have revealed several important recipes for optimal pretraining performance that can be universally beneficial across various problems and models.
Our findings confirm that pretraining can significantly improve the performance of tabular deep models and provide additional evidence that tabular DL can become a strong alternative to GBDT.
A D ATASETS
We used the following datasets:
• Gesture Phase Prediction (Madeo et al.
• Churn Modeling• California Housing (real estate data, Kelley Pace & Barry (1997))
• House 16H• Adult
(income estimation, Kohavi (1996))
• Otto Group Product Classification• Higgs (simulated physical particles, Baldi et al.
(2014); we use the version with 98K samples available at the OpenML repository Vanschoren et al.
• Facebook Comments (Singh et al.
• Covertype (forest characteristics, Blackard & Dean. (2000))
• Microsoft (search queries, Qin & Liu (2013)).
We follow the pointwise approach to learning-to-rank and treat this ranking problem as a regression problem.
• Weather (temperature, Malinin et al.
We take 10% of the dataset for our experiments due to the its large size.
B H YPERPARAMETERS B. C AT B OOST
We fix and do not tune the following hyperparameters:
• early-stopping-rounds =• od-pval = 0 .• iterations =
For tuning on the MI and CO datasets, we set the task type parameter to “GPU”.
In all other cases (including the evaluation on these two datasets), we set this parameter to “CPU”.
[Table]
[Table]
[Table]
We fix and do not tune the following hyperparameters:
• booster = ”gbtree” • early-stopping-rounds =• n-estimators =
[Table]
B. MLP
We fix and do not tune the following hyperparameters:
• Layer size =
• Head hidden size =
[Table]
B. E MBEDDING H YPERPARAMETERS
We fix and do not tune the following hyperparameters:
• Layer size =
• Head hidden size =
The distribution for the output dimensions of linear layers is UniformInt[1 , 128] .
PLR, T-LR .
We share the same hyperparameter space for models with embeddings across all datasets.
For the target-aware embeddings (tree-based) T-LR , the distribution for the number of leaves is UniformInt[2 , 256] , the distribution for the minimum number of items per leaf is
UniformInt[1 , 128] and the distribution for the minimum information gain required for making a split is LogUniform[1 e - 9 , 0 . 01] .
For the periodic embeddings PLR .
The distribution for k is UniformInt[1 , 128] , the distribution for the σ parameter is LogUniform[0 .
C S YNTHETIC DATASET DETAILS
To generate the corresponding objects targets { y i } ni =1 for randomly sampled objects features { x i } ni =1 and importance vector p ∈
R m we build an ensemble of 10 random oblivious decision trees { T i ( x ) } 10 i =1 of depth 10 , where on each tree level we sample a feature j ∼ Cat ( p ) and a threshold t ∼ Unif(min( x j ) , max( x j )) for a decision rule. For each tree leaf, we sample a scalar l ∼ N (0 , 1) , representing a logit in binary classification. We define the binary targets as follows: y ( x ) =
I (cid:110) 110 (cid:80) 10 i =
1 T i ( x ) > 0 (cid:111) .
We set the size of the dataset n = 50 .
000 and the number of features m = 8 and generate 50 datasets with different feature importance vectors p for the analysis.
D P RETRAINING THE FT-T RANSFORMER MODEL
Here we evaluate the recommended pretraining objectives for pretraining the FT-Transformer model from Gorishniy et al.
We evaluate pretraining for the FT-Transformer on a subset of datasets for the reconstruction, mask prediction [Table] and their supervised variations (mask+target and rec+sup).
The results are in the Table 11.
[Table]
We can see that pretraining provides performance improvements for the FT-Transformer model comparable to those for MLP-PLR, with MLP-PLR remaining state-of-the-art with or without pre- training.
Including transformers does not reveal new patterns or behavior, but provides additional evidence that pretraining does help neural networks on tabular data [Table]
E C OMPARISON TO THE LEARNING RATE SCHEDULERS
Since in our setup pretraining is a technique which helps in the optimization process [Table] we compare it to various commonly used learning rate schedules which are also used as an aid in the optimization.
The results for various learning rate schedulers along with two self-training based pretraining baselines are reported in Table 12.
[Table] We can see that the learning rate schedules provide some improvement and help the optimization process, however, the effect is almost negligible compared to the one from pretraining.
We conjecture that exhaustive hyperparameter tuning diminishes the benefits of using the advanced learning rate schedules.
F D ATASETS WITH MORE CATEGORICAL FEATURES
Additionally, we experiment with datasets that contain more categorical features.
We add 4 datasets, the information about the datasets is presented in Table 13.
[Table]
The results for the MLP and MLP-PLR with self-prediction-based pretrains along with their supervised variations are presented in Table 14.
We can see that results on the datasets with more categorical features align with the results in the main text: pretraining strategies based on self-prediction improve upon the supervised baselines and target-aware objectives help further increase the downstream performance.
G S HARE OR SPLIT LEARNING RATE AND WEIGHT DECAY BETWEEN PRETRAINING AND FINETUNING ?
Here we demonstrate that tuning and using the same learning rate and weight decay for both pretraining and finetuning results in similar performance to tuning these parameters separately for the two stages.
We opt for sharing the learning rate and weight decay for pretraining and finetuning in all the experiments in the paper.
[Table]
[Table]
H E ARLY - STOPPING CRITERIONS
Here we demonstrate that early stopping the pretraining by the value of the pretraining objective on the hold-out validation set is comparable to the early stopping by the downstream metric on the hold-out validation set after finetuning.
See Table 16 for the results.
This is an important practical observation, as computing pretraining objective is much faster than the full finetuning of the model, especially on large scale datasets.
[Table]
I A PPLYING AUGMENTATIONS TO GBDT S
We adopt the augmentations used in pretraining to GBDTs by augmenting the datasets before GBDT tree construction, effectively enlarging datasets with random column resampling to match the number of pertrubations the neural network is exposed to during pretraining (tens of millions of randomly corrupted samples).
We report results in Table 17.
We observe that adding noisy augmented samples to the datasets deteriorates GBDT performance significantly.
J S UMMARY OF PRETRAINING METHODS
For summary of the pretraining methods mentioned in the paper see Table 18.
[Table]
[Table]
K E XTENDED T ABLES W ITH E XPERIMENTAL R ESULTS
The scores with standard deviations for single models and ensembles are provided in 19 andrespectively.
G E ↑
C H ↑
C A ↓
HO ↓
O T ↓
H I ↑
F B ↓
AD
[Table]
W E ↓
C O ↑
M I ↓
C a t B
o o s t
[Table]
B o o s t
[Table]
M L P no p r e t r a i n i ng
[Table]
+ [Table] a r
[Table]
e
[Table]
G E ↑
C H ↑
C A ↓
HO ↓
O T ↓
H I ↑
F B ↓
AD
[Table]
E ↓
C O
[Table]
M
[Table]
↓
C a t B oo s t
[Table]
L P no p r e t r a i n i ng
[Table]