Prediction of the Vertical Bearing Capacity of Piles in Cold Saline Environments by a Multi-Dimensional Machine Learning Approach

Abstract

This study proposes an innovative methodology that integrates finite element simulation, machine learning, and interpretable model analysis to predict the vertical bearing capacity of piles in cold saline environments. Initially, Python scripts are developed to drive the ABAQUS platform, and LHS (Latin Hypercube Sampling) is employed to generate random parameter combinations to construct a multi-dimensional ML (machine learning) database. Six ML models, including XGBoost and LightGBM, are developed with hyperparameters optimized by cross-validation and grid search. Model performance is evaluated by five metrics (R², MSE, RMSE, MAE, and MAPE). Finally, parametric sensitivity is analyzed by the SHAP (SHapley Additive exPlanations) method. The study demonstrates that: (1) the XGBoost and LightGBM models achieve optimal performance on the test set, and the generalization ability significantly exceeds other models; (2) pile diameter is the primary factor influencing vertical bearing capacity, and corrosion depth exhibits higher sensitivity than corrosion thickness; and (3) the bearing capacity of the pile is predicted by using the automated parametric modeling method based on Python (3.8)-ABAQUS (2022). The automated modeling and prediction framework may serve as a reference for pile design in similarly complex environments.

1. Introduction

Salt-laden soil is a distinct geological formation in cold marshland areas. Pile foundations may be corroded by salt-laden soil under seasonal freeze–thaw cycles, and this corrosion reduces the bearing capacity of the pile foundations. Thus, it is necessary to consider the effect of erosion on the pile foundation of highways and bridges in salt marsh environments. However, it remains a major challenge to accurately predict the load-bearing capacity of piles in cold marsh saline soils [1,2,3]. Shao et al. developed a numerical method to simulate the damage and degradation of concrete piles in sulfate saline soil [4]. Yunusaliyev et al. studied the effects of environmental aggressiveness and changes in the properties of saline soils on horizontally loaded piles [5]. However, a standardized theoretical framework has not been established. Traditional methods, such as static load tests and empirical formulae, often fail to capture the nonlinear dependency between these multiple factors and the ultimate bearing capacity. Finite Element Analysis (FEA) may simulate soil–pile interactions, but it is limited by calculation efficiency and adaptation to different site conditions. A robust data-driven approach has the potential to improve the accuracy of prediction since the rapid advancement of machine learning (ML) has shown robust applications in pile foundation engineering. Momeni et al. employed a genetic algorithm (GA) for optimizing a Artificial Neural Network (ANN) model to predict the bearing capacity of piles [6]. Fattahi et al. used two optimization algorithms, Fruit Fly Optimization (FFO) and Invasive Weed Optimization (IWO), to predict the load-bearing capacity of piles [7]. Sun et al. highlighted a Support Vector Regression (SVR) model optimized by the Grey Wolf Optimizer (GWO) algorithm to predict the ultimate bearing capacity of embedded rock piles [8]. Chen et al. developed a hybrid model based on four ML algorithms and Ensemble Learning (EL) to predict the ultimate bearing capacity of rock-socketed shafts [9]. However, there are still limitations in current predictions of the ultimate bearing capacity of piles: (1) Few existing models have been specifically developed for cold and swampy regions. (2) It is challenging to build a comprehensive database for prediction models due to the limited field data [10]. The data samples from field tests often exhibit high correlation, leading to overfitting and misleading results [11].

Tree boosting is a highly effective and widely used machine learning method [12]. The Extreme Gradient Boosting (XGBoost) and the Light Gradient Boosting Machine (LightGBM) algorithms are efficient gradient boosting frameworks for managing high-dimensional nonlinear data and capturing complex feature interactions. In recent years, XGBoost and LightGBM have successfully addressed several challenges in geotechnical engineering. Zhang et al. employed an efficient reliability analysis framework utilizing an XGBoost surrogate model to evaluate the failure probability of unsaturated slopes experiencing rapid decline. The model considered the depth-dependent variability of spatially heterogeneous soil [13]. Zhang et al. calculated the reliability of the time-dependent characteristics of the Bazimen Landslide in the Three Gorges Reservoir Area, utilizing XGBoost and LightGBM algorithms [14]. Wang et al. proposed a tree-based model, LightGBM, to predict the intensity of rock bursts [15].

This study proposes a hybrid approach integrating numerical simulation with an ML model. Python scripts are utilized to systematically modify parameters such as pile geometry, material properties, and soil characteristics in the ABAQUS package. A diverse dataset is created for ML by automating model generation. Subsequently, the XGBoost and LightGBM models are developed and employed to predict the vertical bearing capacity of corroded piles in cold marsh environments. The ABAQUS model is verified successfully by the experimental results. The XGBoost and LightGBM models achieve better fitting performance compared to other models, and the two models exhibit the highest accuracy and superior generalization ability. The approach offers a significant reduction in research costs and time compared to traditional field test-based methods by automating parameter variations and computational processes.

2. Numerical Simulations

The pile foundation deteriorates because it is corroded in salt marsh environments. The corrosion is simulated by reducing the elastic modulus of the pile body [16]. The spalling thickness and corrosion depth represent lateral and vertical corrosion of the pile, respectively. It was found that corrosion primarily occurs within 8 m below the surface, exhibiting a corrosion depth of 0–8 m and a spalling thickness of 0–16 cm [17].

The corrosion effects in cold saline environments are captured through two key parameters: corrosion depth (h, ranging from 0.1 to 8.0 m) and spalling thickness (δ, ranging from 0.01 to 0.20 m). These parameters represent the cumulative structural consequences of temperature fluctuations, salinity concentration, and freeze–thaw cycles on the pile body. In the finite element model, the corroded zone is assigned a separate material with a negligibly small elastic modulus (E = 300 Pa) rather than reducing the elastic modulus of the original pile material by a percentage. The current model addresses the structural effects of corrosion at a given degradation state rather than modeling the electrochemical corrosion process itself. Each simulation represents a steady-state condition at a specific corrosion level; by varying h and δ across wide ranges, the dataset captures the pile response at different stages of corrosion progression.

The developed 2D model is compared with experimental data to validate the proposed numerical framework [18]. In this model, the stress–strain behavior of the soil is described by the Mohr–Coulomb constitutive model. The corroded region is modeled with a reduced elastic modulus, scaled by a small factor (1 × 10⁻⁶ or less) to prevent matrix singularity. As the normal pile–soil interface is defined by hard contact, appropriate local mesh refinement is applied around the contact area to ensure computational accuracy and minimize boundary effects. Figure 1 shows the mesh of the model, and Figure 2 illustrates the load–displacement curve of the simulation. It is found the bearing capacity is 614 kN in the numerical model. The experimental bearing is 587.51 kN [18]. The difference is about 4%, indicating that the proposed 2D numerical model is accurate in predicting the bearing capacity of the pile foundation in salt marsh environments.

The model employs a three-step analysis procedure: (1) a geostatic step to establish the initial stress field under gravity loading, during which the pile elements are deactivated using the Model Change technique; (2) a static step to activate the pile elements and establish the pile–soil contact (surface-to-surface contact with penalty friction coefficient μ = 0.25); and (3) a static step with displacement-controlled loading (vertical displacement u₂ = −0.5 m applied at the pile head, with nlgeom = ON) to simulate the pile loading process. The bearing capacity is defined as the reaction force (RF2) at the pile head node when the vertical displacement reaches 0.05 m. The soil domain is modeled as a 25 m × 70 m rectangle with CAX4 elements (4-node and 3-node axisymmetric elements). Boundary conditions include fixed bottom (u₁ = u₂ = 0), roller sides (u₁ = 0), and axisymmetric axis constraints.

It should be noted that the 2D axisymmetric model inherently assumes that the pile geometry, soil stratigraphy, loading, and corrosion distribution are all symmetric about the pile’s central axis. In reality, corrosion may occur non-uniformly around the pile circumference. The present model therefore represents a conservative or idealized scenario, and its extension to fully 3D non-symmetric cases is a potential direction for future work.

In the ABAQUS model, ‘corrosion depth’ is implemented by assigning the reduced elastic modulus to the pile elements located within a specified depth range from the ground surface (0–8 m, as noted in the manuscript). ‘Spalling thickness’ is simulated by deactivating or assigning a negligibly small stiffness to a corresponding layer of elements at the perimeter of the pile within the corroded depth. The Python 3.8 script automatically modifies the material assignments and element sets based on the sampled parameter values.

3. Methodology

The methodology consists of three components. Figure 3 presents the detailed workflow. Initially, the random function of Python is utilized to generate the dataset. Following data collection and preprocessing, a dataset with a multi-dimensional feature space is established and split into a training set (80%) and a testing set (20%). Subsequently, six ML models are developed, trained, and evaluated. Specifically, the training phase incorporates a systematic hyperparameter optimization process, utilizing grid search combined with 5-fold cross-validation to identify the optimal hyperparameters. The performance of each model is then assessed using the R-squared, RMSE, MAE, and MAPE metrics. Finally, Mean Decrease in Impurity (MDI) and SHapley Additive exPlanations (SHAP) analyses are applied to conduct feature importance ranking and global interpretations of the developed models. In this context, ‘the term multi-dimensional’ refers to the eight-dimensional input feature space defining the pile–soil system in cold saline environments. This space consists of eight specific parameters, pile diameter (D), pile length (L), spalling thickness (δ), corrosion depth (h), elastic modulus of pile (Ep), elastic modulus of soil (Es), internal friction angle (φ), and cohesion (c), which are collectively used to predict a single target output: the vertical bearing capacity (Q).

3.1. Data Preparation

The dataset is generated from numerical simulations using the ABAQUS finite element platform. This study selects eight key parameters as shown in

Table 1. The geometric and material parameters of pile and soil.

	Diameter (m)	Length (m)	Density (kN/m3)	Elastic Modulus (MPa)	Poisson’s Ratio	Cohesion (kPa)	Friction Angle (°)
Pile	1.0~2.0	30.0~60.0	25.0	(1.5~4.0) × 104	0.2	/	/
Soil	/	/	18.0	15.0~40.0	0.3	10.0~30.0	10~30

. The eight input parameters are selected based on their established influence on pile bearing capacity: pile diameter (D, 1.0–2.0 m) and pile length (L, 30–60 m) directly determine shaft resistance and end-bearing capacity; spalling thickness (δ, 0.01–0.20 m) and corrosion depth (h, 0.1–8.0 m) characterize corrosion damage extent; elastic modulus of pile (Ep, 15–40 GPa) represents the structural stiffness of the intact pile body; and the Mohr–Coulomb soil parameters including elastic modulus (Es, 15–40 MPa), internal friction angle (φ, 10–30°), and cohesion (c, 10–30 kPa) govern the soil’s shear strength and deformation behavior. The current model assumes a homogeneous soil layer, which is a simplification adopted for the parametric study. Pore water conditions are not explicitly modeled as separate features because the Mohr–Coulomb model uses effective stress parameters.

A Python-based ABAQUS script is employed to develop a numerical model and establish a database, which includes eight parameters and the corresponding bearing capacities. Specifically, a settlement of 50 mm corresponds to the vertical ultimate bearing capacity of the pile. An improved Latin Hypercube Sampling (LHS) method [19] is employed to combine parameters. First, samples are obtained by identifying equal-probability intervals within the variable domain for each variable [20]. The stratified unit order is determined via random permutation in each dimension, and a uniformly distributed random offset is superimposed to mitigate the effect of grid alignment. Furthermore, the standardized samples are mapped onto the actual project to ensure that the generated parameter combinations align with the engineering constraints of corrosion width. The method improves spatial coverage and reduces computational redundancy by the introduction of physically constrained randomness. The improvement is achieved by dimension-independent permutations coupled with uniform perturbation mechanisms. A total of 600 simulations were performed, representing a balance between adequate coverage of the eight-dimensional parameter space via Latin Hypercube Sampling and the available computational resources for batch processing in ABAQUS. Six hundred models are batch-generated and computed by executing a Python-based finite element script. Subsequently, all corresponding parameters are saved as CSV files. The vertical bearing capacity corresponding to a 50 mm pile-top settlement is extracted for all ODB files and saved as a CSV file by using a separate data extraction script written in Python. Figure 4 presents the frequency distribution and correlation of the generated data.

3.2. Overview of Machine Learning

3.2.1. XGBoost

The XGBoost model is a powerful and scalable tree-boosting ML framework with a sparse-aware algorithm [21]. Figure 5 illustrates the schematic of XGboost. The algorithm incorporates advanced techniques such as tree pruning, column sampling, and parallelization to accelerate training without compromising accuracy. The core strength lies in the ability to enhance model generalization by regularization strategies and an efficient split-point determination mechanism. A pre-sorting algorithm is employed to perform a global scan of feature values, resulting in an optimal split-point selection. Additionally, an automatic missing-value handling mechanism is employed to manage missing data directly without preprocessing [22]. XGBoost supports multi-threaded parallel computation and user-defined loss functions, demonstrating high accuracy and stability on small- to medium-sized datasets. Consequently, XGBoost has been widely adopted in various domains [23].

The model is written as a sum of multiple trees:

$${\widehat{y}}_i={\displaystyle {\sum }_{k=1}^K}{f}_k\left(x_i\right)$$

(1)

where $f_k\left(x_i\right)$ is the $k$th tree. A loss function may be defined to quantify the discrepancy between the predicted (true) values and the objective function:

$$L\left(\varnothing \right)={\displaystyle {\sum }_{i=1}^N}l\left(y_i,{\widehat{y}}_i\right)+{\displaystyle {\sum }_{k=1}^K}\mathsf{\Omega }\left(f_k\right)$$

(2)

where $l\left(y_i,{\widehat{y}}_i\right)$ is the loss function; $\mathsf{\Omega }\left(f_k\right)$ is the regularization term to prevent overfitting, defined as:

$$\mathsf{\Omega }\left(f_k\right)=\mathsf{{\rm Y}}\mathrm{T}+{\displaystyle \frac{1}{2}}\lambda {‖W‖}^2$$

(3)

where $T$ is the number of leaves in the tree; $W$ is the weight vector of the leaves; $\mathsf{{\rm Y}}$ and $\lambda$ are the regularization parameters, respectively. The second-order Taylor expansion is employed to approximate the objective function of XGBoost:

$$L^{\left(t\right)}\approx {\displaystyle {\sum }_{i=1}^N}\left[g_i{f}_t\left(x_i\right)+{\displaystyle \frac{1}{2}}{h}_i{f}_t^2\left(x_i\right)\right]+\mathsf{\Omega }\left(f_t\right)$$

(4)

where $g_i={\displaystyle \frac{\partial l\left(y_i,{\widehat{y}}_i^{\left(t-1\right)}\right)}{\partial {\widehat{y}}_i^{\left(t-1\right)}}}$, $h_i={\displaystyle \frac{{\partial }^{2}l\left(y_i,{\widehat{y}}_i^{\left(t-1\right)}\right)}{\partial {{\widehat{y}}_i^{\left(t-1\right)}}^2}}$. Each leaf node in the tree is assigned by a weight $w_j$, and the corresponding loss function at the leaf nodes is given by:

$$L^{\left(t\right)}={\displaystyle {\sum }_{j=1}^T}\left[G_j{w}_j+{\displaystyle \frac{1}{2}}{H}_j{w}_j^2\right]+\mathsf{{\rm Y}}T+{\displaystyle \frac{1}{2}}\lambda {\displaystyle {\sum }_{j=1}^T}{w}_j^2$$

(5)

where $G_i={\sum }_{i\in I_j}{g}_i$, $H_i={\sum }_{i\in I_j}{h}_i$. The optimal leaf weights $w_j$ is obtained from the optimization equation:

$$w_j^{\ast }=-{\displaystyle \frac{G_i}{H_j+\lambda }}$$

(6)

The weight is combined with the objective function to obtain the objective value of the optimal segmentation:

$$L^{\left(t\right)}=-{\displaystyle \frac{1}{2}}{\displaystyle {\sum }_{j=1}^T}{\displaystyle \frac{G_j^2}{H_j+\lambda }}+\mathsf{{\rm Y}}T$$

(7)

Finally, $L^{\left(t\right)}$ may be used to guide the selection of the best tree structure.

3.2.2. LightGBM

LightGBM is an algorithm developed by Microsoft Research Asia based on the GBDT framework [24]. The core principle is to build an ensemble of weak models, and each iteration aims to minimize the gradient of the loss function. The gradient boosting algorithm is employed to combine a histogram-based approach with a leaf-growth strategy. A maximum depth is limited on the tree to enhance the training efficiency and reduce memory usage [25]. Figure 6 depicts the level-wise and leaf-wise growth strategies. All leaves at the same depth are split simultaneously according to the level-wise growth approach. Only the leaves with the maximum information gained at the same depth are selected for splitting in the direction of growth. The strategy enhances parallel optimization and effectively regulates model complexity [23].

The general form of the loss function for the LightGBM model may be expressed as: $L\left(y,F\left(x\right)\right)$, where $y$ is the true value and $F\left(x\right)$ is the predicted value of the model. A new base model may be found for the $i$th iteration to minimize the loss function:

$$h_i\left(x\right)=arg min L\left(y,F_{i-1}\left(x\right)+h\left(x\right)\right)$$

(8)

where $F_{i-1}\left(x\right)$ is the integration of the first $i-1$ models and $h\left(x\right)$ is the predicted value of the $i$th model. Each iteration must calculate the residuals between the predicted and true values of the model to fit the next base model. The residual $r_i$ is calculated as:

$$r_i=y-F_{i-1}\left(x\right)$$

(9)

A decision tree is chosen as the basic model to fit the residuals. The process is written as:

$$h_i\left(x\right)=\arg min{\sum }_{i}L\left(y_i,F_{i-1}\left(x_i\right)+h\left(x_i\right)\right)$$

(10)

A growth strategy, known as “Leaf-wise”, is employed to construct decision trees. The reduction in the loss function is computed after partitioning the sample into left and right child nodes at each leaf node, and the split yielding the highest gain is chosen. The process is expressed by:

$$Gain={\displaystyle \frac{1}{2}}\left[{\displaystyle \frac{G_L^2}{H_L+\lambda }}+{\displaystyle \frac{G_R^2}{H_R+\lambda }}-{\displaystyle \frac{{\left(G_L+G_R\right)}^2}{H_L+H_R+\lambda }}\right]-\lambda$$

(11)

where $G_L$ and $G_R$ are the sum of the first-order gradients of the left and right child nodes; $H_L$ and $H_R$ are the sum of the second-order gradients of the left and right child nodes; $\lambda$ is the regularization parameter; and $\mathsf{{\rm Y}}$ is the minimum gain threshold for splitting. LightGBM may efficiently process data and deliver accurate predictions with the aforesaid steps.

3.2.3. Grid Search and Cross-Validation

Grid search (GS) and k-fold cross-validation (CV) are employed for the systematic tuning and validation of hyperparameters. As illustrated in Figure 7, GS explores a predefined subset of hyperparameter combinations to identify the configuration that optimizes the performance of the model [26]. A predefined hyperparameter space is systematically traversed to comprehensively evaluate the effect of various parameter configurations on the performance of the model. This study incorporates a k-fold cross-validation mechanism to enhance model robustness and mitigate sensitivity for the stochastic distribution of training data. As shown in Figure 8, the mechanism divides the training set into mutually exclusive k subsets. Each subset serves as the validation set in turn. The remaining subsets constitute the training set, and the process is executed iteratively [27]. The results from each iteration provide an evaluation of model performance for different data partitions, and the final performance metric is derived as the mean validation score over kth iterations. The approach effectively eliminates assessment bias induced by a single data partition and ensures more reliable and representative hyperparameter tuning results. The integration of GS with k-fold CV facilitates effective hyperparameter tuning, improves performance on the training and validation sets, and strengthens the generalization capability on unseen data to ensure the efficiency and reliability of the model.

3.3. Development of the Model

At this stage, the ML database is obtained. The dataset is split into training (80%) and test (20%) sets using a random state of 42 (a widely adopted fixed seed in machine learning to ensure deterministic data splitting) for reproducibility. Subsequently, the training uses six ML models, including Decision Tree (DT), Random Forest (RF), Extreme random Tree (ET), K-Nearest Neighbors (KNN), XGBoost, and LightGBM, respectively. The Scikit-learn library and other auxiliary libraries are used to build and train the algorithmic models in Python. A 5-fold CV method is employed to assess the stability of the models, and hyperparameters are optimized by GS to enhance the performance of the model. The two best models are selected by comparing the differences and fitting abilities of the different models. Special attention is given to overfitting and underfitting issues during the training process. These issues are mitigated by adjusting model complexity and selecting appropriate regularization methods. Additionally, hyperparameter tuning is a critical step in improving the performance of the model. The parameter space is systematically explored by GS to identify the optimal combination of the parameters. Different models require distinct tuning strategies. The tree-based models may adjust the number of trees, maximum depth, etc. The linear models may improve the coefficients of the regularization terms.

The complete hyperparameter search spaces and optimal values for all six models are summarized in

Table 2. The parameter space.

Model	Hyperparameter	Search Space	Optimal Value
DT	max_depth	[3, 4, 5]	5
	min_samples_split	[10, 15, 20]	10
	min_samples_leaf	[5, 10, 15]	10
	max_features	[0.6, 0.8]	0.8
	ccp_alpha	[0.6, 0.8]	0.01
RF	n_estimators	[50, 100	100
	max_depth	[3, 5, None]	None
ET	n_estimators	[50, 100]	100
	max_depth	[5, 7]	7
	min_samples_split	[5, 10]	10
	min_samples_leaf	[5, 10]	5
	max_features	[0.7, 0.8]	0.8
KNN	n_neighbors	[3, 5, 7]	7
	weights	[uniform]	uniform
	p	[1]	1
XGBoos	learning_rate	[0.01, 0.1]	0.1
	max_depth	[3, 5]	3
	n_estimators	[100, 300]	300
LightGBM	num_leaves	[31, 63]	63
	learning_rate	[0.01, 0.1]	0.1
	n_estimators	[50, 100]	100

. The scoring metric for GS is negative mean squared error. For tree-based models, the key hyperparameters include maximum tree depth and minimum sample constraints; for boosting models, the learning rate and number of estimators are additionally tuned. Advanced optimization strategies, such as genetic algorithms (GAs) and particle swarm optimization (PSO), have been applied for hyperparameter tuning of ensemble ML models in structural engineering applications [28]. In this study, GS combined with k-fold CV is adopted, primarily due to the manageable size of the hyperparameter space and the deterministic nature of the search process, thereby ensuring full reproducibility of the results.

3.4. Evaluation Metrics

This study employs five distinct indicators to comprehensively quantify the accuracy and robustness of the regression model: the coefficient of determination (R²), mean square error (MSE), root mean squared error (RMSE), mean absolute error (MAE), and mean absolute percentage error (MAPE). R² is a well-established metric in classical regression analysis. It is defined as the proportion of variance “explained” by a regression model and used as a measure in predicting the dependency of the variables based on the independent variables [29]. MSE represents the mean squared prediction error and is frequently used in loss function design to penalize large errors. RMSE denotes the mean of the square roots of the squared errors between the fitted data and the original data [30]. RMSE retains the sensitivity of MSE to large errors, while restoring the error metric to the original data scale through a square root transformation. MAE is another widely used metric to evaluate the performance of the model [31]. The metric provides an intuitive, unbiased estimation of the error and is well-suited for scenarios where the effect of squared errors needs to be avoided. MAPE indicates the relative error of the predicted value compared to the true value [32]. The error is normalized to percentages to facilitate cross-scale comparisons. The formulae of five metrics are presented as follows [33]:

$$R^2=1-{\displaystyle \frac{{\sum }_{i=1}^n{\left(y_i-p_i\right)}^2}{{\sum }_{i=1}^n{\left(y_i-p_m\right)}^2}}$$

(12)

$$MSE={\displaystyle \frac{1}{n}}{\displaystyle {\sum }_{i=1}^n}{\left(y_i-p_i\right)}^2$$

(13)

$$RMSE=\sqrt{{\displaystyle \frac{1}{n}}{\displaystyle {\sum }_{i=1}^n}{\left(y_i-p_i\right)}^2}$$

(14)

$$MAE={\displaystyle \frac{1}{n}}{\displaystyle {\sum }_{i=1}^n}\left|y_i-p_i\right|$$

(15)

$$MAPE={\displaystyle \frac{1}{n}}{\displaystyle {\sum }_{i=1}^n}\left|{\displaystyle \frac{y_i-p_i}{y_i}}\right|$$

(16)

where $p_m$, $y_i$, and $p_i$ are the mean, experimental, and model values, respectively; $n$ is the number of datasets.

4. Results and Discussion

4.1. Comparison of Regression

Figure 9 illustrates the regression performance of the model, where the blue dots represent the training set and the red dots represent the test set, respectively. The regression slopes are fitted to assess the performance of the model by plotting the true values on the x-axis and the predicted values on the y-axis, respectively. The previous studies [34] found that a slope greater than 0.80 reflects a strong agreement between the true and predicted values. The results indicate that the DT and KNN models show inferior performance, and the top-performing models are XGBoost and LightGBM. XGBoost and LightGBM exhibit a slope of 0.976 and 0.973 in the test set respectively, indicating an excellent one-to-one correspondence between the predicted and true values. A slope close to unity further suggests that both models exhibit a strong correlation between the predicted and true values. The XGBoost and LightGBM models are more robust than the other models, resulting in a better fit to the real data with lower errors.

4.2. Analysis of Test Sets

Figure 10 illustrates the predictive performance of six regression models on the test set by comparing the alignment between the predicted and true values. The results indicate that the DT and KNN models perform weaker than the other models. Significant deviations are observed between the predicted and true values in both DT and KNN models. The RF and ET models are better than the DT and KNN models, but lower than XGBoost and LightGBM models. It is observed that XGBoost and LightGBM exhibit the best performances on the test set, and their prediction curves closely align with the true curves, indicating that these two models effectively capture complex data patterns and maintain high predictive accuracy. The GBDT framework is employed to minimize errors by iterative optimization and effectively mitigating the overfitting. Additionally, XGBoost incorporates L1 and L2 regularizations to enhance the stability of the model when it deals with complex data. LightGBM enables efficient data processing and maintains robust predictive capability through the learning approach of histogram-based decision trees. The results indicate that XGBoost and LightGBM outperform all other models and show strong generalization capabilities.

4.3. Statistical Evaluation

Figure 11 presents the variations in evaluation indicators on the training and test sets. DT and RF, as representative tree-based models, perform well on the training set but exhibit limited generalization ability on the test set. The R² of DT reaches 0.866 in the training set but drops to 0.759 in the test set. The error also increases dramatically in DT. In contrast, RF maintains 0.927 for R² in the test set, and all error metrics are considerably better than for DT. ET and KNN exhibit slightly inferior performance compared to RF. ET achieves 0.920 for R² in the test set, indicating superior generalization ability. KNN exhibits higher errors due to the reliance on local samples. The MAE and MAPE of KNN are relatively higher, suggesting that KNN is less capable of handling complex data structures. However, XGBoost and LightGBM perform well on all evaluation indicators, and show strong fitting capability and generalization performance. XGBoost achieves an exceptional R² of 0.998 in the training set, indicating an almost perfect fit to the data. The R² is 0.976 in the test set, showing effective generalization to the unseen data. The test set errors (MSE = 20.329, RMSE = 4.509, MAE = 3.496, MAPE = 3.974%) are substantially lower than the other models, highlighting the robustness of the data variability. LightGBM closely parallels XGBoost since the values of R² are 0.996 and 0.973 in the training and test set, respectively. The error metrics are marginally higher, but the overall difference is minimal, suggesting the strongest generalization ability. The results show that XGBoost and LightGBM exhibit exceptional predictive performance. XGBoost marginally outperforms LightGBM in accuracy, and the two models are well-suited for high-performance regression tasks.

Several measures are employed to address the risk of overfitting. First, 5-fold cross-validation during hyperparameter tuning reduces overfitting to specific train–test splits. Second, regularization is incorporated in XGBoost (L1 and L2 regularization parameters), LightGBM (num_leaves constraint), and Decision Tree (cost-complexity pruning via ccp_alpha). The comparison between training and test performance serves as an overfitting diagnostic: XGBoost shows training R² = 0.998 vs. test R² = 0.976, and LightGBM shows training R² = 0.996 vs. test R² = 0.973, indicating modest and acceptable performance gaps. In contrast, DT exhibits the weakest generalization (training R² = 0.866 vs. test R² = 0.759), which reflects limited model capacity for this problem rather than overfitting. Formal uncertainty quantification methods (e.g., prediction intervals) are not implemented in the current study and could be explored in future work.

4.4. SHAP and MDI Analysis

SHAP analysis is a unified approach to interpreting ML models and introduces the concept of Shapely Additive interpretation [35]. Recent studies have demonstrated the effectiveness of SHAP for improving model interpretability in civil engineering applications. Lv et al. utilized an innovative neural network and SHAP to predict the shear strength of UHPC beams [36]. Abdollahi et al. leveraged SHAP values to elucidate an artificial intelligence (AI)-assisted slope stability analysis [37]. These studies confirm that SHAP provides actionable insights beyond traditional feature importance metrics.

In this study, global SHAP analysis is performed for XGBoost and LightGBM. Figure 12 and Figure 13 show the feature ranking and summary plots, respectively. Figure 12a and Figure 13a depict the average impact of each feature on the output of the model. Figure 12b and Figure 13b are summary plots that illustrate the distribution of SHAP for each feature and the direction of the impact on the model output. It is seen that the varying effects of changes in feature values on the model output are visible by changing the color scale from blue to red. The pile diameter has the greatest effect on the vertical load. In addition, soil characteristics exert a greater influence on the vertical bearing capacity of the pile. The corrosion depth and spalling thickness have relatively small effects on the vertical bearing capacity, possibly due to the lower variability in the data preparation process. However, SHAP analysis yields consistent results in both models, showing that the corrosion depth has a slightly greater effect than the lateral corrosion. Therefore, the erosion resistance of concrete at certain depths is of particular importance in practical engineering.

As shown in Figure 14, Mean Decrease in Impurity (MDI) analysis is performed for XGBoost and LightGBM models to further validate the SHAP-based feature importance rankings (Figure 14). The MDI-based feature ranking for XGBoost is: D (0.3854) > c (0.3142) > Es (0.1545) > φ (0.1212) > h (0.0135) > δ (0.0075) > L (0.0022) > Ep (0.0015). For LightGBM it is: c (0.1747) > φ (0.1747) > D (0.1724) > Es (0.1548) > h (0.1185) > δ (0.0913) > L (0.0686) > Ep (0.0448). Both MDI and SHAP methods identify pile diameter (D) and soil properties (c, Es, φ) as highly influential features. The primary difference is that MDI tends to assign higher relative importance to features involved in early tree splits (e.g., cohesion c ranks very high in MDI), while SHAP provides a more nuanced attribution accounting for feature interactions and considers each feature’s contribution across all predictions. It is worth noting that the ABAQUS finite element model is itself a deterministic numerical formulation: given the same input parameters, it produces the same output. Traditional bearing capacity formulas (e.g., Meyerhof, Vesic) are explicit and direct deterministic relationships. The ABAQUS model, while also deterministic, involves implicit, multi-stage numerical procedures where the relationships between input parameters and output are intrinsically complex. The SHAP analysis applied to ML models trained on this deterministic simulation data thus serves to reveal the implicit interaction effects between corrosion and geotechnical parameters that are embedded within the numerical solution but cannot be directly observed from the formulation itself.

The SHAP analysis reveals that corrosion depth (h) exerts a stronger influence on the vertical bearing capacity than spalling thickness (δ). From a physical perspective, corrosion depth determines the length of the pile section assigned the degraded material, directly affecting the shaft resistance along the corroded zone. A deeper corrosion penetration means a longer pile segment with near-zero stiffness, leading to greater loss of shaft friction capacity and reduced overall bearing capacity. In contrast, spalling thickness primarily affects the cross-sectional area at a localized level. The global bearing capacity is more sensitive to the extent (depth) of degradation than to its intensity (thickness) at any given cross-section. The SHAP summary plots further reveal that the effect of corrosion depth on bearing capacity depends on the pile diameter—larger diameter piles are less sensitive to corrosion depth than smaller diameter piles, indicating a nonlinear interaction between these features.

5. Conclusions

This study predicts the vertical bearing capacity of pile foundations in cold saline and alkaline environments. Datasets are batch-generated by establishing a 2D numerical model. Automated scripts are developed by combining Python. The ML database is constructed with multiple factors such as pile–soil materials and corrosion parameters. Subsequently, six ML models are developed and analyzed. The following conclusions are drawn below:

(1)

The ML database is developed by using Python to script ABAQUS models, and the LHS method is used for the automatic generation of random parameters.

(2)

XGBoost and LightGBM show the best performance of the six models. Moreover, XGBoost and LightGBM have potential in predictions because they are effectively generalized to new data.

(3)

The pile diameter exerts the greatest effect on the vertical bearing capacity of the pile.

(4)

The depth of corrosion has a more significant effect than the corrosion thickness on the vertical bearing capacity of the pile. Therefore, the depth of corrosion is prioritized for the design of the piles in cold saline environments.

Several limitations of this study should be acknowledged. First, the dataset is entirely generated from 2D axisymmetric FE simulations; direct validation against field measurements is needed. Second, the soil is modeled as a single homogeneous layer with Mohr–Coulomb behavior; multi-layered soils and groundwater effects are not considered. Third, corrosion is simulated by assigning a separate material with a negligibly small elastic modulus to the corroded zone; other degradation effects such as strength loss and reinforcement corrosion are not modeled. Fourth, the analysis considers steady-state conditions without time-dependent corrosion progression. Future work could extend to 3D models with non-uniform corrosion, incorporate field test data, develop time-dependent prediction models, and implement formal uncertainty quantification methods such as prediction intervals.