The effects of mismatched train and test data cleaning pipelines on regression models: lessons for practice

Introduction

In recent years, there has been an explosion in the use and study of machine learning (ML) models (Aggarwal et al., 2022). Such models have been applied to a number of different datasets to address a range of problems (Libbrecht & Noble, 2015; Athey, 2018; Molina & Garip, 2019). ML models are ‘data-driven’ because they are trained on specific data to complete a specific task, and their performance and characteristics are directly dependent on the data on which they are trained. However, the end-goal is always to use these models to perform some downstream task on different, unseen data. The implicit assumption is that the data on which these models are actually applied have the same distributions and characteristics as the data on which the models were trained.

This assumption that the data at inference time matches the data used during training does not always hold in practice. Frequently, data engineering and ML teams are distinct (Dimensional Research, 2019; Friedel, 2023), and perform their tasks semi-independently. Improvements and changes are made to data engineering pipelines that affect production data. ML models may not be fitted to this updated production data, as there are many costs associated with the retraining, retesting, and redeployment of the models to production (Wiggers, 2019; Hecht, 2019; Paleyes, Urma & Lawrence, 2022), with costs for ML projects performed by ITRex, for example, varying between $26,000 and $300,000 (Shashkina, 2024). As a result, the data on which these models are trained may not match the data on which they are applied in practice. The frequency of such mismatches is also exacerbated by the now common practice of reusing datasets (Paullada et al., 2021) and possible differing quality in training and test data (Budach et al., 2022). This is at odds with the ML research space, where the focus is on so-called ‘benchmark datasets’ that have perfectly matched training and test data. These benchmarks are limited in number and in many cases will not match the production data (Suresh & Guttag, 2021; Groh, 2022).

Given these potential mismatches between training and production data, it is important to account for where such differences can arise and what impact they can have on model performance. One important source of such discrepancies is through data cleaning pipelines. These pipelines aim to identify and correct data quality issues within datasets. Such corrections can have a potentially large impact on the data, and thus model behaviour. Historically, data quality and ML model fitting and selection have been done somewhat independently (Li et al., 2021). However, these processes can have significant interactions with each other (Mazumder et al., 2022; Northcutt, Athalye & Mueller, 2021; Budach et al., 2022).

In this article¹ , we investigate the impact that mismatched data cleaning pipelines can have on ML models, specifically for regression tasks, for which the effects of data quality/data cleaning are generally less well-understood than for classification tasks (Martín, Sáez & Corchado, 2021). Using two datasets from Li et al. (2021), we define a regression task on each. For each dataset, we create a collection of different data cleaning pipelines. Train and test sets are cleaned independently, leading to a number of cleaned versions of each dataset. For each cleaned version of a given train dataset, three different regression models are trained (Random Forest Regression (Breiman, 2001), Gradient Boosted regressor, and extreme gradient boosting (XGBoost) regressor (Chen & Guestrin, 2016)). These models are then tested on each of the cleaned test sets. These experiments lead us to identify a number of key findings:

• 1.

  The method used for cleaning the test data can be far more influential on the performance than the method for cleaning the training data.

• 2.

  The best performance is not necessarily achieved when the same cleaning process is applied in the test and training data.

• 3.

  Different cleaning pipelines for test data can change the best-performing model type for a given training cleaning pipeline.

The main contributions of this article are as follows:

• Identification of the need to test the effects of mismatches between training and test set cleaning pipelines. While the effects of changes in production data on ML model performance is of known importance, it is not often considered from the perspective of changes in cleaning pipelines.

• A number of experiments highlighting how such mismatches can affect the performance of regression models. Regression models are frequently under-emphasised in the literature, despite their prominence in real-world application.

In “Background” we introduce the relevant background work; “Experiments” describes the data, models, and cleaning setups used in the experiments; “Results” and “Discussion” present and discuss the results; finally, “Conclusions” offers general conclusions, limitations, and future work.

Background

The problem of data quality for ML models has long been studied (Blake & Mangiameli, 2011; Gudivada, Apon & Ding, 2017). Li et al. (2021) note that the issues of data quality and ML model performance are often addressed separately by the ML and databases communities. The authors collected a number of real-world datasets with different error types and rates and tested classical classification algorithms. They showed that there is a consistent impact from data cleaning with respect to model performance, and this can mean that data cleaning is generally more applicable than creating very robust models. Mazumder et al. (2022) identified limitations of current benchmarks in ML research and noted the importance of data quality in training ML models. Northcutt, Athalye & Mueller (2021) investigated how pervasive errors in labels can destabilise the ML benchmark. Many test data are mislabelled, and correcting these errors can change which models perform relatively better or worse. This highlights the need to improve the labelling of test data in order to better choose which models to use. Budach et al. (2022) showed how the performance of ML models can be affected by systematically introducing data quality errors into training data, highlighting the (lack of) robustness for some model-dataset combinations.

In addition to ML model performance, there is also an increasing emphasis on issues such as fairness and explainability with respect to data quality. Zelaya (2019) defines volatilities to measure the effects of preprocessing on different data points. They note that different data preprocessing can impact predictions of different data points in different ways, and this could be correlated to specific features. Biswas & Rajan (2021) note that all steps in the ML pipeline can cause unfairness, but the focus has thus far generally been on the models themselves. Many typical data preprocessing steps (missing value removal, data filtering, feature engineering, etc.) can introduce unfairness, and this effect can be positively or negatively related to model performance. Guha et al. (2023) shows how automatic data cleaning can hurt fairness, with issues such as missing values more common in disadvantaged groups.

The studies on data quality’s effects on ML models have generally been limited to classification tasks (Martín, Sáez & Corchado, 2021), and there is a relatively high level of understanding of how classification models deal with noisy data. Algorithms such as XGBoost and Random Forests either have built-in methods for addressing noise or have been shown empirically to deal with it well (Gómez-Ríos, Luengo & Herrera, 2017; McDonald, Hand & Eckley, 2003). Other tools like k-nearest neighbor (k-NN) (Biau & Devroye, 2015) and support vector machines (SVMs) (Schölkopf, 2002) have been shown to be sensitive to noise in labels (Martín, Sáez & Corchado, 2021). Most of the the literature on noise in regression tasks has been focused on SVMs (Martín, Sáez & Corchado, 2021; Borah & Gupta, 2019; Cherkassky & Ma, 2004; Suykens et al., 2002). Robustness for other algorithms such as Random Forests and gradient boosted models has been investigated to some extent (Brence & Brown, 2006; Roy & Larocque, 2012; Einziger et al., 2019), but these efforts are infrequent, and the emphasis is more on parameter tuning robustness rather than noise in the data. The performance of regression models is measured in a fundamentally different way than classification models: predictions are not only right or wrong, but instead have their accuracy expressed as a (potentially highly variable) numerical error. This difference could affect the sensitivities of performance metrics to data quality concerns, emphasising the need for dedicated study.

The aforementioned data quality concerns advocate for the necessity of regularly maintaining and updating data preprocessing pipelines as new information is received. However, these updates to preprocessing pipelines can cause shifts in the data, affecting the performance and applicability of an already-trained ML model. Retraining and redeploying an ML model has many costs associated with it, and these costs are rapidly growing for the most advanced artifical intelligence (AI) models (Cottier et al., 2024). Because of this, how best to address and manage these costs is an active area of research. Mahadevan & Mathioudakis (2024) introduce the concept of ‘cost-aware’ retraining for ML models, where a balance is struck between staleness costs (the costs of lower model performance on updated data) and retraining costs (money and time costs of retraining). This is also being considered in industry, where questions are regularly asked about how production data are changing (Baier, Reimold & Kühl, 2020; Podkopaev & Ramdas, 2021) and when retraining should be done (EvidentlyAI, 2024). Most of the thinking on this issue is on the effects of new data or changes in the distributions of the production data not as a result of preprocessing, but rather some other external factor.

All of the work described above is relatively recent, highlighting the increasing need to address these issues. We differentiate from this related work in a number of ways:

• We focus on the less well-understood regression models, rather than the more commonly studied classification models.

• We do not use synthetic errors, but rather real-world datasets.

• We compare mismatched training and test set cleaning pipelines, rather than simply cleaned vs. dirty training and test sets.

Experiments

We use two different datasets that have one or many data cleaning issues and were originally used for classification tasks, defining new regression tasks on them. These data (and the general approaches to cleaning) are from CleanML (Li et al., 2021) (https://github.com/chu-data-lab/CleanML). The three types of errors addressed in these experiments are duplicates, missing values, and outliers. For each, different identification and correction strategies are defined and all possible combinations tested. This creates multiple cleaned training and test sets.

Three different types of regression model are trained: Random Forest regression (RFR), Gradient Boosted regressor (GBR), and XGBoost regressor (XGB). These three models were chosen because they strike a good balance in task performance, model complexity, and training times on the datasets, while not having been well-studied in the literature for data quality robustness. Models are fitted to the various cleaned training sets, and subsequently tested on different cleaned test sets.

In this article, we focus on scale in the number of data cleaning pipelines. As a result, we generally limit our analysis to simple models, data cleaning, and performance metrics. More sophisticated and nuanced approaches are possible and offer potential avenues for further research.

Experimental setup

For each dataset, an initial set of 20 different train-test splits (in a 70–30 split) from the full uncleaned data are created. Assuming $n$ different cleaning pipelines, the experiments proceed as follows for each of the train-test splits:

• 1.

  Both the training and test sets are cleaned independently using $n$ cleaning pipelines. This results in $n$ cleaned training sets and $n$ cleaned test sets

• 2.

  The three different models are each trained on all $n$ cleaned training sets, giving a total of $3n$ fitted models

• 3.

  The performance of all $3n$ models are tested on all cleaned test sets, for a total of $3n^2$ performance scores

For a given training cleaning pipeline and test cleaning pipeline, model performance is averaged over 20 different train-test splits. For these experiments, performance is measured using the $R^2$ score, which serves well as a general overview of model performance, highlights the differences that can be observed, and has already been used in testing model robustness (Einziger et al., 2019). Figure 1 shows the experimental procedure for a single train-test set and model type. The same train-test splits are used for all three model types (RFR, GBR, XGB) tested.

The USCensus data is only cleaned for categorical missing values. This gives three different cleaning pipelines: ‘delete’, ‘mode’, and ‘dummy’, as described in “Data Cleaning”. Hence, per training-test split, nine different models are trained and these nine models are tested on three different test sets, for a total of 27 combinations.

For the Airbnb data, there are 98 possible cleaning pipelines based on all combinations of missing value, outlier, and duplicate detection and correction techniques. Thus, 294 total models have been trained. Each model is tested on the 98 test sets for a total of 28,812 results. This is repeated for 20 different train-test splits and the results are averaged.

Due to the large number of possible cleaning pipelines in the Airbnb data, we will generally refer to them using a number. A table showing the definitions of each cleaning pipeline number is available in the Appendix.

The splitting of the data into train-test splits and subsequent cleaning of both is performed locally. Model training and inference is done on the Netherlands National Supercomputer Snellius (https://www.surf.nl/diensten/snellius-de-nationale-supercomputer). Experiments were run on the ‘rome’ node, which uses an AMD Rome CPU. Processes were run in parallel across 16 cores with 28 GB memory, and used approximately 9,457 System Billing Units (roughly 591 h total compute time).

Results

We present the main results of our experiments across the approximately 6,000 total models. As the number of fitted models and performance measurements is so large, it is not possible to present all results here. Instead, we highlight some key findings from the analysis. To see the full results, the Supplemental Material includes a set of CSV files that includes all the results and a Jupyter notebook that loads and displays them for ease of review. A separate folder contains the code for reproducing the experiments (https://github.com/jim-g-n/mismatched_data_cleaning).

The findings apply to both datasets. In the following, we provide the evidence for each. Where behaviour across different model types is similar, we only report results for the Random Forest, and note where this is not the case.

Finding: the method used to clean the test data can have a much greater impact on performance than the method used to clean the training data

USCensus data

Figure 2 shows the performance of the RFR models trained on different cleaned training sets when applied to different cleaned test sets for the USCensus data. The x-axis indicates the cleaning pipeline applied to the test sets, the y-axis the $R^2$ score, and the colours differentiate the cleaning applied to the training sets. Results are averaged over different train-test splits.

For a given test cleaning pipeline, there is relatively low variance in the performance based on the training set cleaning pipeline. One exception to this is the test set cleaned by dummy variables, in which case the dummy trained model heavily outperforms the delete and mode trained models.

However, the variance between performance for different test cleaning pipelines is much larger, with all models performing far worse on the delete test set, and all models performing best on the dummy test set.

Airbnb data

Figure 3 shows boxplots of the RFR models’ performance for different test set cleaning for the Airbnb data. The x-axis shows the test set cleaning pipeline number, and the y-axis shows the boxplot distributions of the $R^2$ scores for different training set cleaning pipelines on the test set. For a given training cleaning-test cleaning combination, performance is again averaged over the 20 train-test splits.

As in the USCensus data, the variance between test sets can be higher than the variance within test sets. For example, the variance in scores when changing from test set number 0 to test set number 97 is higher than when changing between different training sets within test set 0. There is a noticeable cyclical behaviour in the scores, which corresponds to different data issues being addressed in different ways. For test sets 0–13, missing values are deleted, while for other test sets, they are estimated. Other patterns arise in similar ways.

For this dataset, the differences are more noticeable with a different type of model. Figure 4 shows the same boxplot for the GBR models. In this case, the differences between test sets 0–13 (where missing values are deleted) and test sets 14–97 (where missing values are estimated) are much greater, with all model performances in test sets 14–97 falling below even the minimum model performance on test sets 0–13.

Finding: the best performance is not necessarily achieved when the same cleaning process is applied in the test and training data

USCensus data

For this finding on the USCensus data, we can again refer to Fig. 2. For the test sets cleaned with dummy or mode, the best-performing models use the same train cleaning (i.e., dummy and mode, respectively). However, for the test sets cleaned with delete, the best-performing model is the one with dummy cleaning on the train sets. However, we note that these performance differences are small and may not be statistically significant.

Airbnb data

Figure 5 compares the performance of RFR models when the training cleaning pipeline matches the test cleaning pipeline, and the best-performing training cleaning pipeline for a given test cleaning pipeline. In most cases (93 out of 98), the training cleaning pipeline that performs best for a given test cleaning pipeline does not match the test cleaning pipeline. This means that for given cleaned test/production data, it is not necessarily best to try to match the cleaning pipeline on one’s training data. In this case, there are six unique training cleaning pipelines that perform best on at least one test cleaning pipeline, which cover the range of cleaning options.

Figure 6 shows the boxplots for matched cleaning vs. best cleaning model performance when considered over different train-test splits. For ease of visibility, only every 5th test cleaning pipeline is shown. In all cases, there is an overlap in the boxplots between matched vs. best for a given test cleaning pipeline, i.e., the best never outperforms the matched in all possible train-test splits. Performing a paired two sample t-test to compare the means over different train-test splits results in 87 of 98 test cleaning pipelines where the best vs. matched scores differ significantly at 5% significance (we could expect approximately five false rejects for multiple hypothesis testing).

As with Finding 1, a similar behaviour is observed for the GBR and XGB models, but is less pronounced. In the case of the GBR models, the differences are not statistically significant over different train-test splits (a larger number of train-test sets could change this).

Finding: different cleaning pipelines for test data can change the best-performing model type for a given training cleaning pipeline

USCensus data

Figure 7 shows the relative performance of different types of model trained with the same training cleaning pipeline on different test cleaning pipelines. In these results, all models are trained using ‘mode’ cleaning.

When using ‘mode’ cleaning on the training data, the XGB model always performs best when models are compared using the same test cleaning, while RFR always performs worst. However, if the two models are tested on data cleaned using different cleaning pipelines, it can be the case that the RFR model performs best. If ‘dummy’ test cleaning is used for the RFR model and ‘delete’ test cleaning is used for GBR, it can appear that RFR is a better choice.

Airbnb data

Figure 8 shows the relative performance of different model types when the training data is cleaned using setup number 0. If the model types are compared using the same test cleaning pipeline, RFR always performs best and GBR always performs worst. However, GBR on test cleaning pipelines 0–7 (missing values deleted, outliers detected with standard deviation or ignored) always performs better than both RFR and XGB on test cleaning pipelines 14–97 (missing values estimated).

Discussion

It is already known that the effects of changing data cleaning pipelines on model performance can be specific to a given model-dataset combination (Budach et al., 2022). This means that the findings of these experiments will not necessarily apply/arise in all cases and can be model, dataset, and cleaning pipeline dependent. However, we note that results are consistent between the two datasets tested, and that similar research on comparable problems has led to notable results (Li et al., 2021; Budach et al., 2022; Northcutt, Athalye & Mueller, 2021). With this in mind, we discuss the general findings, the intuitive reasoning behind them, and suggest where such outcomes may arise and how they should be dealt with.

Changing the test set cleaning can have larger impacts on model performance than changing the model itself, either in terms of training set cleaning or model type. A possible explanation for this is that the changed distribution of the test data is significantly easier to model, leading to drastically improved performance for many models. Figure 9 shows the distribution of the cleaned ‘Price’ variable in the Airbnb data for different cleaning setups covering the range of possible solutions. We see that the level of smoothness in the distributions of this target variable changes based on cleaning setup, which could have a significant impact on model performance. This finding could mean that improving data cleaning pipelines in production could be more effective in maximising performance than retraining and redeploying models, as long as these changes make the cleaned production data more accurately reflect reality.

It can also be tempting to try to match training cleaning and production data cleaning as closely as possible. However, these results show that certain training cleaning approaches can be highly effective across multiple different test cleaning pipelines. In many cases, the best-performing training cleaning pipeline is different from the test cleaning pipeline. As each cleaning decision relies on some sort of assumption, it could be that the assumptions of certain pipelines are less restrictive than others, leading to models that extend better to other conditions. However, predicting which cleaning pipeline and model combinations will perform best in advance can be difficult.

As an example, Table 4 shows the top five best performing training cleaning pipelines in the Airbnb data based on different criteria. For the first two columns, we show the training cleaning pipelines whose distributions most closely match those in the test data averaged over all test cleaning pipelines. In order to quantify similarity in distributions, we calculate the Jensen Shannon distance based on histograms with 100 bins. This is a relatively crude approach and can be sensitive to choice of number of bins, but gives a good initial impression. The ‘Price’ column uses only the distribution of the target variable, while the multiple variable column uses the target plus two representative features, one specific to the particular Airbnb rental (number of reviews) and one for the region of the Airbnb (cost of living index). We note that the best performing training cleaning pipelines can differ depending on which criteria is used, and one cannot simply focus on cleaning to match distributions.

Another difference we see is in the number of unique training cleaning pipelines performing best for a given test cleaning pipeline. When analysing the RFR models, there were six unique training cleaning pipelines that performed best on at least one test cleaning pipeline. When considering distributions instead, there are 22 training cleaning pipelines that most similarly match the ‘Price’ distribution on at least one test cleaning pipeline. In other words, it is potentially more likely that a cleaning pipeline could perform well in terms of distribution matching than in terms of downstream model performance.

All of this suggests that there is an interaction between the models and training cleaning pipelines, and using only distributions for selecting cleaning pipelines may miss these interactions. One possible explanation for this is that some models have built-in tools for dealing with data quality issues, and perhaps perform better when using poorly cleaned data. This could especially be true when using deep learning models, which theoretically deal well with capturing complex distributions. However, such models are not immune to data quality issues, remaining dependent to some extent on the cleaning process. This is especially true when it comes to robustness and fairness, which are active areas of research (Whang & Lee, 2020; Whang et al., 2023). Furthermore, these models are expensive and time-consuming to train, or are pre-trained (Han et al., 2021; Papernot et al., 2017), meaning that they will still need to deal with mismatches in training and production data cleaning pipelines over time. It is also possible that these simpler models we have tested could be more robust and less at risk of overfitting. Northcutt, Athalye & Mueller (2021) found that lower capacity models could perform better than higher capacity ones after correcting errors on test data; likewise, Budach et al. (2022) found that in some cases simpler models were more robust to data quality issues (but this was dependent on the dataset). Considering all these possibilities, there is room for performing further analysis as in this article to ascertain to what extent our findings apply to more sophisticated models.

The final takeaway from these findings is the need for transparency in data cleaning and the evaluation of ML models. Results using different cleaning pipelines should be reported, as adjusting these can have significant impacts on performance. This could in some cases be used to make results appear better than they are, especially when making non-like-for-like comparisons to other models/cleaning pipelines. In general, performance differences of state-of-the-art models on benchmark datasets are often very small. For example, the percentage correct for the top five models on the CIFAR-10 image classification task (Krizhevsky & Hinton, 2009) varies between 99.42% and 99.61% (https://paperswithcode.com/sota/image-classification-on-cifar-10, accessed September 2024); for the object detection task on COCO minival (Lin et al., 2014), the box AP scores of the top five models vary between 64.6% and 65.9% (https://paperswithcode.com/sota/object-detection-on-coco-minival, accessed September 2024). However, these benchmark datasets would have gone through a cleaning pipeline themselves, which could affect the relative performance of different models. This need for transparency could also be present in fairness issues for such problems. For example, the USCensus dataset tested has a number of potentially sensitive variables (Race, Sex, Native Country). Table 5 shows the counts of different races over the full dataset and the subset of rows with at least one missing value. Shown in brackets is the percentage. We note that minorities are more likely to have missing values, and they will thus have data cleaning applied disproportionately. As a result, mismatches in data cleaning pipelines could have a larger effect on minorities. Understanding these effects could be crucial in ensuring fairness.

Conclusions

With the increasing amount of data reuse and the known effects that data cleaning can have on ML models and their performance, the need to test and quantify different data cleaning pipelines is apparent. The experiments performed in this article showed some unexpected findings, such as the potential advantages in the performance of the ML model when training and test set cleaning pipelines are mismatched. The choice of models can also be affected by the cleaning pipeline applied to test data, which may arise particularly when different groups are testing on the same dataset. We also see that model performance can vary more through changing test set cleaning pipelines than training set cleaning pipelines.

Taking this into account, it could be more prudent to select models based on their performance on a range of different test cleaning pipelines, as this would hopefully make them more robust if changes are made to production data cleaning in the future. Accurately reporting on multiple cleaning pipelines when evaluating new models can also increase confidence in the wide-ranging applicability of a model. Such efforts are probably less necessary in the case where it is possible or inexpensive to retrain models.

There are some limitations to this work and avenues for future extensions. As mentioned in Li et al. (2021) and Neutatz et al. (2022), there is a limited number of real-world datasets with dirty, non-synthetic, and impactful errors plus gold standard cleaned versions. As a result, our analysis has been limited to only two of these datasets. While the results are consistent across these two datasets, further experiments are necessary to generalise all findings. That being said, there are some intuitive explanations as to why we might expect these results to generalise. Also worth noting is that we tested a relatively small set of moderately complex regression models. As this problem and approach are relatively new, focussing on simpler, under-studied regression models served a good initial foundation, but further testing using more complex models or other types of models will garner deeper insights.

Supplemental Information