The Damang Gold Mine is in southwest of Ghana, West Africa approximately 300 km west of Accra (5˚11'N, 1˚57'W), and about 30 km north of Tarkwa. The deposit is found within the Tarkwaian sediments of the Ashanti Belt. The Ashanti Belt strikes northeast with a broadly synclinal structure and comprises lower Proterozoic sediments, as well as volcanic rocks and the Birimian System metasediments. The Tarkwaian sedimentary sequence within the Ashanti Belt exhibits lower-intensity metamorphism compared to other rock formations in the region. It is composed of immature sedimentary units and coarse-grains that include several series, such as the Huni series, the Banket series, the Damang phyllite series, and the Kawere series.

The mine mineralisation occurs within the Tarkwaian’s paleoplacer deposits. These deposits are composed of distinct tabular units of quartz pebble conglomerates, commonly referred to as reefs. These reefs are interspersed between argillaceous sandstone blocks and quartzites. The mineralisation in the Damang deposit is likely associated with the concentration of gold within these paleoplacer deposits. Hydrothermal, oxide and Witwatersrand-style paleoplacer mineralisation are exploited at the mine. The hydrothermal deposits occur within the pyrite and pyrrhotite alteration selvedge and are found next to the echelon quartz veins. Accessory vein minerals such as ilmenite, carbonate, tourmaline and apatite are also linked to the gold. Conventional open-pit methods are employed, which utilise standard truck-shovel techniques to mine the ore. Loading and hauling activities are undertaken using excavators in backhoe configurations. To support drill-and-blast and haulage operations, vehicle, road, and bench maintenance, dust, and erosion control are undertaken. For optimal fragmentation and blast control, both conventional (Nonel) and electronic detonators are employed in rock blasting. The location of the study area is depicted in Figure 1 .

A dataset comprising the parameters: spacing (S), burden (B), geometric stiffness (K), stemming height (T), backbreak (BB) and powder factor (P) was used. A total of 60 data points were obtained from the Goldfields Ghana Limited, Damang Mine. Table 1 represents the statistical description of the dataset employed.

Table 1. Statistical description of dataset.

The train_test_split was used on the dataset to separate into training and testing sets for all algorithms. This is important to assess how effectively the model generalizes to new, unseen, or future data. The dataset was split into 80:20, where 80% was for training with the corresponding 20% for testing. 12 out of 60 data points were for testing, and 48 out of 60 data points were for training. The training set (comprising input parameters and target variable) is used in a process of adjusting the model’s internal parameters to make it capable of learning patterns and relationships from the data after which the testing set is employed to assess the trained model’s performance in real-world scenarios.

This prediction task employs machine learning algorithms for regression modelling using GBDT, LightGBM, BPNN, GNN and KAN. These algorithms were selected for their proven capabilities in handling non-linear relationships and complex datasets in mining applications [17] . Using a standard 80:20 training-testing split ratio, all three algorithms process the same input parameters (burden, spacing, stemming height, powder factor, and geometric stiffness) to predict backbreak values.

Theory

GBDT ensures that the errors produced in the past are fixed by adding the prior under-fitted forecasts to the ensemble one after the other. In the gradient boosting process, models are iteratively built, with the errors and losses (loss function) from previous models being calculated and used as target variables to improve predictions on subsequent models and combining the predictions from the multiple models to minimise errors [13] . This process repeats until a stopping condition is satisfied or a maximum number of models is reached [18] . The gradient descent method is utilised in this algorithm to minimise the loss function. According to [19] for the initial model prediction Equation (1). Figure 2 illustrates the implementation of the GBDT algorithm.

$F_{0\left(x\right)}=\arg \min \gamma {\displaystyle {\sum }_{i=1}^{n}nL\left(y_i,\gamma \right)}$ (1)

where; L is the loss function, $\gamma$ is the predicted value, $y_i$ is the observed value, n is the number of observations, $\arg \min \gamma$ denotes finding the value of $\gamma$ that minimizes the loss function

The loss function is calculated by Equation (2),

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

Implementation

The dataset (n = 60) was initially sectioned using stratified partitioning into training (n_train = 48, 80%) and test (n_test = 12, 20%) sets depicted in Figure 3 . To enhance model accuracy and ensure robust performance assessment, particularly given the limited dataset size, k-fold cross-validation with k = 5 was implemented on the training data. This process systematically divided the training dataset into five equally sized folds. The GBDT model underwent five iterations of training and evaluation, with each iteration utilizing a distinct fold as the validation set while the remaining four folds served as training data. This approach allowed for a more reliable estimation of the model’s generalization performance and demonstrated its stability across different subsets of the training data.

Through systematic hyperparameter optimization, it was determined that 300 estimators yielded optimal model performance. The model’s configuration was further refined through additional hyperparameters, notably the maximum depth and learning rate. An exhaustive grid search strategy, implemented via GridSearchCV, was employed to identify the optimal hyperparameter combination. This methodological approach systematically explored the hyperparameter space, evaluating various permutations to determine the configuration that maximized the predictive model’s performance. A summary of the optimal tuned hyperparameters is presented in Table 2 .

Theory

According to [20] , LightGBM is a robust gradient boosting framework that leverages decision trees to enhance model efficiency and minimize memory consumption. It introduces two innovative techniques known as Gradient-based One Side Sampling (GOSS) and Exclusive Feature Bundling (EFB) [12] [21] . The GOSS technique gives more weight to instances with larger gradients, indicating that they are under-trained. These instances contribute more to the calculation of information gain. GOSS selectively keeps instances with large gradients (above a threshold or within the top percentiles) and only randomly discards instances with small gradients [22] . This improves the accuracy of information gain estimation compared to uniform random sampling, especially when the range of information gain values is large. EFB bundles exclusive features (mutually exclusive features that have no simultaneous non-zero values) into a single feature. This significantly reduces the complexity of histogram building from being proportional to the number of data points multiplied by the number of features to being proportional to the number of data points multiplied by the number of bundles. Since the number of bundles is much smaller than the number of features, this approach improves the training speed of the framework without sacrificing accuracy. The architecture of LightGBM is depicted in Figure 4 .

Parameters that can be tuned in LightGBM are max depth (maximum limit of tree depth is effective in controlling overfitting), categorical feature (feature to be used for model training), bagging fraction (proportion of data selected for each iteration.) num iterations (total count of iterations to be executed), num leaves (total count of leaves in a tree), max bin (maximum count of bins for grouping feature values), min data in a bin (least amount of data contained in a bin), task (operation to be performed, either training or prediction) and feature fraction (proportion of features selected for each iteration). Overfitting, which occurs when models excessively capture details and noise from the training data, resulting to poor performance on new data, should be watched for in decision trees. The model accuracy is enhanced and the risk of overfitting is reduced through K-fold cross-validation technique [23] .

Implementation

The experimental methodology employed a systematic data partitioning approach, where the dataset (n = 60) was stratified and randomly split into training (n_train = 48, 80%) and test (n_test = 12, 20%) sets. For hyperparameter optimization, an exhaustive grid search strategy was implemented using GridSearchCV, coupled with a k-fold cross-validation mechanism (k = 5) to ensure robust model selection and mitigate overfitting risks. The grid search systematically explored the defined hyperparameter space to identify the optimal configuration that maximized model performance. The k-fold cross-validation procedure partitioned the training data into five stratified subsets, enabling comprehensive model evaluation across multiple data combinations while maintaining the statistical distribution of the target variable. This rigorous validation framework ensured the selected hyperparameters generalized well across different data subsets, while the held-out test set provided an unbiased assessment of the final model’s performance. Table 2 presents the optimal hyperparameters for the model.

Theory

BPNN, originally discovered in 1969, has been the most widely used neural network because of its ability to learn complex relations [24] . BPNN enables the computation of the loss function gradient concerning all network weights [14] . The BPNN learning process involves forward propagation and backward propagation.

During forward propagation, input signals enter the neural network from the input layer through hidden layers to the output layer [25] . The network’s weights and biases remain unchanged, and the current layer’s neuron outputs affect only the following layer. If the desired output isn’t reached, the process can switch to backpropagation to correct errors [26] . With backpropagation, the error signal is the difference between the actual and desired network outputs and sent from the output layer back through the layers to the input layer [25] [27] . The network’s weights are remodelled based on this error feedback, continuously adjusting them to bring the actual output closer to the expected output [25] . The weights of the network are then updated according to a gradient descent rule [14] . The architecture of BPNN is shown in Figure 5 .

Implementation

Feature preprocessing was implemented through the MinMaxScaler class from scikit-learn, which normalized input parameters to a uniform range, thereby preventing the dominance of features with larger magnitudes in the learning process. The dataset (n = 60) underwent stratified partitioning into training (n_train = 48, 80%) and test (n_test = 12, 20%) sets. To ensure robust model evaluation and hyperparameter tuning, especially given the limited dataset size, k-fold cross-validation with k = 5 was applied to the training data. This involved iteratively training and validating the model across five distinct subsets of the training data.

The neural network architecture was configured with specific hyperparameters: ReLU activation function, hidden layer dimensions of 64 neurons, and a maximum iteration limit of 1000 epochs (representing complete forward and backward passes of the entire dataset). A random state of 42 was established to ensure experimental reproducibility, while the network’s weight optimization employed the Adam (Adaptive Moment Estimation) optimizer. The Adam optimizer is known for its adaptive learning rate mechanism, achieved by tracking exponentially decaying averages of previous gradients and their squared values. This allows it to adjust the learning rate dynamically, improving convergence rates in various optimization problems [28] . The ReLU activation function is mathematically as shown in Equation (3):

$h=\max \left(0,a\right)$ (3)

where a represents any real number, such that the function returns 0 for inputs less than or equal to 0, and returns a otherwise. A summary of the BPNN optimally tuned hyperparameter configuration is summarized in Table 2 .

Theory

Graph Neural Networks (GNNs) extend traditional neural networks to operate on graph-structured data, making them effective for capturing complex relationships between data points. GNNs represent data as nodes interconnected by edges, where each node contains feature information, and the edges define the relationships between nodes [29] .

The Graph Convolutional Network (GCN), first proposed by [30] , is a specific variant of GNN that generalizes convolutional operations to graph-structured data. In GCNs, each node’s representation is updated by aggregating information from its neighbours. The basic operation in a GCN layer is shown in Equation (4):

$H^{\left(l+1\right)}=\sigma \left({\tilde{D}}^{-\frac{1}{2}}\tilde{A}{\tilde{D}}^{-\frac{1}{2}}{H}^{\left(l\right)}{W}^{\left(l\right)}\right)$ (4)

where $H^{\left(l\right)}$ represents the node features at layer $l$, $Ã=A+I$ is the adjacency matrix with added self-connections, $\tilde{D}$ is the degree matrix of $Ã$, $W^{\left(l\right)}$ is the trainable weight matrix for layer $l$, and $\sigma$ is a non-linear activation function [31] .

For regression tasks like backbreak prediction, GNNs offer advantages by considering the relationships between different blasting scenarios rather than treating each instance independently. This approach enables the model to leverage similarities and patterns across different blast design parameters to improve prediction accuracy [32] .

Implementation

Feature normalization was implemented through MinMaxScaler to ensure uniform feature scaling, preventing features with larger magnitudes from dominating the learning process. The dataset (n = 60) underwent stratified partitioning into training (n_train = 48, 80%) and test (n_test = 12, 20%) sets depicted in Figure 3 . To ensure robust model evaluation and hyperparameter optimization, particularly given the limited dataset size, k-fold cross-validation with k = 5 was applied to the training data. This involved iteratively training and validating the model across five distinct subsets of the training data.

A k-nearest neighbors (kNN) graph was constructed to establish the topological structure of the data. The choice of a neighborhood size of k=10 for the kNN graph was determined through empirical evaluation during the hyperparameter tuning process, where various values of k were tested to identify the configuration that best captured the local data manifold while balancing computational efficiency and predictive performance. This selection aimed to ensure sufficient connectivity within the graph to propagate information effectively without introducing excessive noise from distant neighbors.

A three-layer Graph Convolutional Network (GCN) architecture was implemented using the PyTorch Geometric framework. The network architecture incorporated dropout regularization to prevent overfitting. The model configuration featured the following components:

i. Input layer: Accepting normalized blasting parameters,

ii. Three graph convolutional layers with ReLU activations,

iii. Two fully connected layers for the final prediction,

iv. Dropout regularization between layers.

Hyperparameter tuning for the GNN model, including the learning rate, number of hidden units in each layer, and dropout rates, was conducted using an exhaustive grid search strategy. This process systematically explored a predefined range of values for each hyperparameter, with the optimal combination selected based on the model’s performance during the 5-fold cross-validation. The training was conducted using the Adam optimizer, known for its adaptive learning rate mechanism, which dynamically adjusts learning rates to improve convergence. The mean squared error (MSE) loss function was employed for optimization, with model checkpoints saved periodically during training to capture the best performing model throughout the training epochs.

Theory

The Kolmogorov-Arnold Network (KAN) is a neural network architecture inspired by the Kolmogorov-Arnold representation theorem, which states that any multivariate continuous function can be represented as a composition of continuous functions of a single variable and addition operations [33] . Unlike traditional neural networks that use fixed activation functions, KANs employ learnable univariate activation functions represented as splines, providing greater flexibility in function approximation. KAN architecture is presented in Figure 6 .

The KAN’s mathematical foundation stems from Kolmogorov’s superposition theorem, which stipulates that any continuous function $f:{\left[0,1\right]}^n\to R$ is expressed in Equation (5)

$f\left(x_1,x_2,\cdots ,x_n\right)={\displaystyle {\sum }_{q=1}^{2n+1}{\Phi }_q\left({\displaystyle {\sum }_{p=1}^n{\varphi }_{q,p}\left(x_p\right)}\right)}$ (5)

where ${\Phi }_q$ and ${\phi }_{\left\{q,p\right\}}$ are continuous univariate functions.

KANs implement this theorem by representing each univariate function as a spline with learnable parameters. The spline function of order $k$ with grid size $g$ has a form shown in Equation (6)

$s\left(x\right)={\displaystyle {\sum }_{i=0}^g{c}_i{B}_i^k\left(x\right)}$ (6)

where $B_i^k$ are basis splines and $c_i$ are learnable coefficients [34] . This approach provides KANs with high expressivity while maintaining interpretability, as the network can be decomposed into simpler univariate functions.

Implementation

The KAN implementation used a systematic approach for feature preprocessing, model optimization, and evaluation. The dataset (n = 60) underwent feature standardization using StandardScaler to normalize all input parameters to a consistent scale. The dataset was then stratified and randomly split into training (n_train = 48, 80%) and test (n_test = 12, 20%) sets.

To ensure robust model evaluation and hyperparameter tuning, particularly given the limited dataset size, k-fold cross-validation with k = 5 was applied to the training data (the 48 data points). This involved iteratively training and validating the model across five distinct subsets of the training data, providing a more reliable estimate of the model’s generalization performance and assessing its stability.

The architecture featured an input layer dimensioned according to the feature count, followed by a hidden layer of neurons, and an output layer with a single neuron. The model was configured with a specific grid size and spline order, which provided a balanced trade-off between model complexity and generalization capability. A regularization parameter was applied to prevent overfitting. The training was conducted using the Adam optimizer. The mean squared error loss function was employed for optimization, with model checkpoints saved periodically during training. The final model was then validated with the held-out test set (the remaining 12 datasets) to provide an unbiased assessment of its performance.

K-fold cross-validation (CV) is a widely adopted and robust technique for evaluating machine learning models, particularly when aiming to ensure generalization capability and prevent overfitting [36] . Unlike a single train-test split, which can yield biased performance estimates, k-fold CV partitions the dataset into k equal subsets. The model is then iteratively trained on k − 1 folds and validated on the remaining fold, repeating this process k times so that each data point serves as both a training and validation example [36] .

This method provides a more reliable estimate of a model’s generalization error by averaging performance metrics across all k iterations [37] . Furthermore, it offers crucial insights into model stability; consistent performance across folds indicates robustness and reduced sensitivity to specific data compositions [38] . Consequently, k-fold cross-validation is an essential tool for developing reliable and generalizable predictive models. The performance metrics (e.g., R², MAE) are computed for each iteration, and the final reported performance is typically the average of these k measurements [38] .

Theory

Hyperparameters govern model capacity and regularisation but are not learned directly from the data; their values must be specified a priori and strongly influence generalisation performance [38] . Grid search with cross-validation remains a widely adopted, reproducible strategy for hyperparameter selection because it exhaustively evaluates a discrete, user-defined search space under a consistent validation protocol [36] [39] . Formally, let $\mathscr{H}=h$ denote the Cartesian product of candidate values for each hyperparameter, $\left\{V_1,\cdots ,V_J\right\}$. For a K-fold scheme, the cross-validated empirical risk for configuration h is represented in Equation (7).

${\hat{R}}_{CV}\left(h\right)=\frac{1}{K}{\displaystyle {\sum }_{k=1}^K{L}_{val}^{\left(k\right)}\left(f_h^{\left(-k\right)}\right)}$ (7)

where $f_h^{\left(-k\right)}$ is the model trained on the K-1 non-held-out folds and $L_{val}^{\left(k\right)}(\cdot )$ is the loss evaluated on the k-th validation fold. The selected configuration minimises this estimate expressed in Equation (8)

$h^{*}=\arg \arg {\hat{R}}_{CV}\left(h\right)$ (8)

Because the grid is discrete, its size grows multiplicatively with the number of tuned hyperparameters, this is expressed in Equation (9).

$\left|H\right|={\displaystyle {\prod }_{j=1}^J\left|V_j\right|}$ (9)

so practitioners often balance coverage and computational cost by focusing on the most influential knobs (e.g., learning rate, tree depth, number of estimators for boosting; hidden width and regularisation for neural networks). Compared with alternatives such as random search [40] or Bayesian optimisation [41] , grid search is simple, deterministic, and easy to reproduce; however, it can be sample-inefficient in high-dimensional spaces. Cross-validation provides an approximately unbiased estimate of out-of-sample error when folds are i.i.d., but model selection on the same resamples can introduce selection bias; a strictly unbiased assessment may use a held-out test set or nested CV [42] .

Several best practices from the literature improve the robustness of GridSearchCV in small-n regression: (i) construct pipelines that apply all preprocessing (e.g., scaling, encoding) within each fold to prevent leakage; (ii) stratify folds by target quantiles when feasible to stabilise error estimates in heteroscedastic settings; (iii) use evaluation metrics aligned with the study objective (e.g., MAE/MSE/R² for this work); and (iv) fix random seeds and shuffle splits to enhance reproducibility [36] [39] . For boosted trees, literature commonly reports strong sensitivity to learning rate and depth lower learning rates with more estimators tend to generalise better, provided early-stopping or adequate regularisation is used [38] [43] . For neural networks, grid sizes are often kept modest and centred on architecture (width, depth) and optimiser settings because training is comparatively expensive [44] .

GridSearchCV in the Context of This Study

Consistent with prior work, this study employs scikit-learn’s GridSearchCV to systematise hyperparameter selection for tabular learners. For GBDT and LightGBM, grids spanned the principal capacity and optimisation controls (e.g., n_estimators, learning_rate, max_depth), evaluated under K = 10 folds, with performance aggregated via the same loss functions later used for testing (MAE, MSE, and R²). The resulting configurations (see Table 2 ) reflect the literature’s guidance on conservative learning rates with sufficient estimators for boosted ensembles. For neural models (BPNN, GNN, KAN), hyperparameters were tuned using compact, problem-informed grids around architecture and regularisation settings while preserving the same K-fold protocol to ensure comparability across learners. All preprocessing (e.g., scaling via MinMaxScaler/StandardScaler) was embedded in fold-wise pipelines to eliminate information leakage, and the final generalisation estimates were computed on the held-out test partition to guard against selection bias.

Machine learning prediction models’ efficacy and performance can be assessed using evaluation metrics. Mean absolute error (MAE), coefficient of determination (R²), and mean squared error (MSE) are the three metrics used in this study to assess how well the models performed. R² evaluates the extent to which the observed results align with the predicted values from the regression line. This assessment provides insights into the degree to which the independent variable accounts for the variability in the model. Essentially, it gauges the effectiveness of the model in explaining the dataset. Mathematically R² can be expressed as shown in Equation (10) [45]

${\text{R}}^2=\frac{\text{SSR}}{\text{SST}}=\frac{{\displaystyle \sum {\left({\hat{y}}_i-\underset{\_}{y}\right)}^2}}{{\displaystyle \sum {\left(y_i-\underset{\_}{y}\right)}^2}}$ (10)

where SSR is Sum Square of Residuals (squared difference between the predicted ( ${\hat{y}}_i$) and the average value ( $y_i$)). SST is Sum Square of Total (squared difference between the actual ( $y$) and average value ( $y_i$)). The MAE is a measure of the prediction error of a model; it is measured by taking the average of the absolute difference between actual values and the predictions. For this, the number of datapoints (n), actual output value (y) and predicted output value ( $\hat{y}$) are considered Equation (11) [46] .

$\text{MAE}=\frac{1}{n}{\displaystyle {\sum }_{i=1}^n\left|y_i-{\hat{y}}_i\right|}$ (11)

MSE is a key metric in statistical analysis and machine learning, used to measure the variation between actual and expected results. The average of the squared deviations between these values is used to compute it, which serves to magnify larger errors, making it particularly useful for models that aim to minimise prediction errors. The mathematical expression for MSE is the expectation of the squared deviation of an estimator from the true parameter value, encompassing both the variance and the bias squared of the estimator [47] . Mathematically, MSE can be expressed as shown in Equation (12)

$\text{MSE}=\frac{1}{n}{\displaystyle {\sum }_{i=1}^n{\left(y_i-{\hat{y}}_i\right)}^2}$ (12)

where y is the true value, $\hat{y}$ is the predicted value and n is the number of datapoints.