ISCCO: a deep learning feature extraction-based strategy framework for dynamic minimization of supply chain transportation cost losses

Introducing deep learning feature extraction with random forest: achieving efficient customer classification

• Traditional supply chain management often overlooks the multidimensional characteristics of customer behavior, limiting the efficiency and precision of resource allocation (Capó, Pérez & Lozano, 2020). Traditional algorithms also fail to capture this type of nonlinear similarity, restricting their application in this scenario (Baldassi, 2022; Ay et al., 2023; Ikotun et al., 2023).

• This study proposes a new customer classification strategy by combining deep learning with random forests, which not only handles complex nonlinear features but also effectively extracts key information through autoencoders, greatly enhancing the accuracy and generalization capability of the classification.

• As shown in Fig. 2, this process combines autoencoders for feature extraction and random forests for customer classification. The autoencoder compresses the input data into key features, which are then classified by the random forest model. The model’s performance is optimized using cross-validation and grid search, aiming to improve customer segmentation and reduce transportation costs through more accurate pre-shipment decisions.

Implementing deep learning feature extraction with random forest: achieving efficient customer classification

In the context of supply chain cost control, we propose a method combining autoencoders with random forests for customer classification. Autoencoders are used to process input features and extract key nonlinear information. The encoding process can be extended by adding multiple layers and including regularization terms, represented by the equation: (6)${\displaystyle h=f_3\left(W^{\left(3\right)}{f}_2\left(W^{\left(2\right)}{f}_1\left(W^{\left(1\right)}x+b^{\left(1\right)}\right)+b^{\left(2\right)}+\lambda \parallel W^{\left(2\right)}{\parallel }_2\right)+b^{\left(3\right)}\right).}$

The decoding process is specifically expressed by the following equation: (7)${\displaystyle x^{\prime }=g_3\left({W^{\prime }}^{\left(3\right)}{g}_2\left({W^{\prime }}^{\left(2\right)}{g}_1\left({W^{\prime }}^{\left(1\right)}h+{b^{\prime }}^{\left(1\right)}\right)+{b^{\prime }}^{\left(2\right)}+\lambda \parallel {W^{\prime }}^{\left(2\right)}{\parallel }_2\right)+{b^{\prime }}^{\left(3\right)}\right).}$

In these equations, x is the input vector, W⁽ⁱ⁾ and W′⁽ⁱ⁾ are the weight matrices for encoding and decoding stages, respectively, b⁽ⁱ⁾ and b′⁽ⁱ⁾ are bias vectors, f_i and g_i are activation functions, λ is a regularization coefficient, h⁽ⁱ⁾ and x⁽ⁱ⁾ represent outputs at each layer. Subsequently, using the compressed features h obtained from the autoencoder, the classification result of the random forest model C(x) can be defined by: (8)${\displaystyle C\left(x\right)=\sum _{i=1}^N{w}_i\cdot c_i\left(h\right)+\gamma \cdot \text{Var}\left(c_i\left(h\right)\right).}$

Here, N is the number of decision trees, c_i is the classification result of the i-th tree on the compressed feature h, w_i represents the weight of the i-th tree, reflecting its importance in the overall classification, γ is an adjustment factor, Var(c_i(h)) measures the variance of the classification results, used to assess the uncertainty of the results. To ensure model generalization and prevent overfitting, we employ cross-validation techniques and optimize model hyperparameters through grid search. The overall performance of the model is evaluated by the weighted average of various metrics under cross-validation, as expressed below: (9)${\displaystyle J=\sum _{i=1}^n{\alpha }_i\left(\frac{1}{k}\sum _{j=1}^k{\text{Metric}}_i\left(M_j,D_{\text{val},j}\right)\right).}$

Here, k is the number of folds in cross-validation, M_j is the model trained on the j-th fold, D_val,j is the corresponding validation set, Metric_i represents the i-th evaluation metric, α_i is the weight of the corresponding evaluation metric.

The specific validation process is shown in the appendix.

Enhanced integer linear programming with genetic algorithm: implementing a cost loss minimization strategy for goods allocation

• Many traditional models rely on a static decision-making environment, assuming that data do not change over time. This results in significant efficiency reductions when the model fails to adapt to new requirements once environmental changes occur (Alfaro, Valencia & Vargas, 2023; Prerna & Sharma, 2022). Moreover, traditional models often struggle to effectively handle uncertainties in the supply chain, such as demand fluctuations and supply disruptions, because they lack mechanisms for flexible decision-making (Dupin, 2022).

• Our proposed integer linear programming model enhanced with a parallel genetic algorithm (GA-ILP) combines the global search capabilities of genetic algorithms with the precise optimization of integer linear programming to achieve efficient optimization of goods allocation in the supply chain. This algorithm not only optimizes total costs resulting from order cancellations or delays but also significantly enhances computational efficiency through parallel processing techniques.

• Figure 3 shows a process where a parallel genetic algorithm (GA-ILP) optimizes an Integer Linear Programming model. It starts by initializing a population, then calculates fitness values. The algorithm evolves solutions through selection, crossover, and mutation. If termination conditions are met, the process ends; otherwise, it continues iterating until the optimal solution is found.

Enhanced integer linear programming with parallel genetic algorithm (GA-ILP)

Research proposes an algorithm for an enhanced integer linear programming (ILP) model using a parallel genetic algorithm (GA-ILP), aimed at optimizing goods allocation to reduce order cancellation rates and transportation costs. The model achieves precise optimization of goods distribution. Initially, an ILP model is constructed with the objective of minimizing the total cost incurred from order cancellations or delays, expressed as: (12)${\displaystyle \text{Minimize}Z=\sum _{i=1}^n\sum _{j=1}^m\left(c_{ij}\cdot x_{ij}+p_{ij}\cdot \left(1-x_{ij}\right)\right)+\lambda \sum _{i=1}^n\sum _{j=1}^m{s}_{ij}\cdot x_{ij}}$

Here, n represents the number of orders, m represents the types of goods. c_ij is the cost if item j in order i is canceled, p_ij is the penalty if item j in order i is delayed. x_ij is a binary decision variable indicating whether to allocate item j to order i, s_ij is the storage or holding cost, and λ is a cost adjustment factor. (13)${\displaystyle \sum _{i=1}^n\left(x_{ij}+\frac{t_{ij}\cdot x_{ij}}{T_i}\right)\le q_j+\frac{1}{m}\sum _{k=1}^m\frac{T_k}{t_{kj}}\forall j}$ (14)${\displaystyle \sum _{j=1}^m\left(x_{ij}+\frac{p_i\cdot x_{ij}}{P_{\text{min},j}}\right)=1+\frac{1}{n}\sum _{k=1}^n\frac{P_{\text{min},k}}{p_k}\forall i.}$

Equation (13) integrates inventory quantities with delivery time constraints. Equation (14) integrates the requirement that each order must be allocated at least one type of item, considering order priority to ensure high-priority orders are prioritized during goods allocation. Decision variable x_ij must not only meet integer conditions but also consider order fulfillment rates and real-time inventory adjustments. Thus, we introduce a continuous decision variable y_ij, representing the probability of fulfilling order i with item j, influenced dynamically by inventory adjustments. The integer condition and fulfillment probability are formulated as: (15)${\displaystyle x_{ij}\in \left\{0,1\right\},y_{ij}=x_{ij}\times \left(1-e^{-\lambda t_{ij}}\right)\forall i,\forall j}$

where e^−λt_ij represents the decayed fulfillment probability due to the response time t_ij, and λ is the decay coefficient. To solve this integer linear programming problem, we use a parallel genetic algorithm for optimization. The algorithm is described as: (16)${\displaystyle \text{Parallel GA}\left(\Theta ,x,y\right)=\text{arg}\underset{x,y}{min}\left\{\alpha \cdot Z\left(\Theta ,x,y\right)+\beta \cdot \text{Var}\left(x,y\right)+\gamma \cdot \text{Stab}\left(x,y\right)\right\}\text{subject to}{g}_k\left(x,y\right)\le 0,h_l\left(x,y\right)=0\forall k,\forall l.}$

Here, α, β, and γ are weighting factors, used to balance the importance of different objectives. Z(Θ, x, y) is the original cost function, Var(x, y) evaluates the variance of the solution for diversity assessment, and Stab(x, y) is a new stability metric, measuring the consistency of solutions across multiple runs. The constraints g_k(x, y) ≤ 0 and h_l(x, y) = 0 represent the model’s inequality and equality constraints, allowing more precise control over the feasibility of solutions. The mathematical description of the algorithm is: (17)${\displaystyle \text{GA-ILP}\left(\Theta ,x\right)=\text{arg}\underset{x}{min}\left\{\alpha \cdot Z\left(\Theta ,x\right)+\beta \cdot \text{Var}\left(x\right)+\gamma \cdot \text{Stab}\left(x\right)+\delta \cdot \text{Cons}\left(x\right)\right\}\text{subject to}{c}_i\left(x\right)\le 0,\forall i}$

where Θ includes the control parameters of the genetic algorithm, the formula’s α controls the impact of the cost function Z(Θ, x). β adjusts the variance of the solution Var(x), measuring solution diversity. γ is the stability metric Stab(x), assessing consistency across multiple runs. δ is the constraint satisfaction metric Cons(x), quantifying the degree of constraint violation of the solution. c_i(x) represents the problem’s constraints, ensuring the feasibility of the solution. The model not only provides a comprehensive optimization framework but also enhances the applicability and efficiency of the algorithm in practical applications through multi-objective and constraint management.

Details of the computations can be found in the appendix.

Overall structure of the ISCCO framework

The core of the ISCCO framework is to efficiently categorize customers using deep learning and utilize this classification to optimize goods allocation strategies, minimizing transportation costs and order cancellation rates. The structure of the framework is as follows: (20)${\displaystyle \text{ISCCO}\left(\Theta ,x,y\right)=arg\underset{\Theta ,x,y}{min}\left\{\alpha \cdot J\left(\Theta ,x,y\right)+\beta \cdot \text{Cost}\left(x,y\right)+\gamma \cdot \text{Risk}\left(x,y\right)\right\}\text{subject to}{g}_k\left(x,y\right)\le 0,h_l\left(x,y\right)=0\forall k,\forall l}$

where α, β, and γ are weighting factors used to balance the importance of different objectives. J(Θ, x, y) is the performance evaluation function based on customer classification, Cost(x, y) represents the total cost incurred from goods allocation, and Risk(x, y) represents the risk arising from order cancellations or delays. In the ISCCO framework, the optimization of customer classification and goods allocation is carried out interactively. This process is represented by the following mathematical model: (21)${\displaystyle {\Theta }_{ISCCO}^{\ast },x^{\ast },y^{\ast }=arg\underset{\Theta ,x,y}{min}\left\{J\left(\Theta \right)+{\lambda }_1\cdot \text{Var}\left(C\left(\Theta \right)\right)+{\lambda }_2\cdot \text{Cost}\left(x,y\right)+{\lambda }_3\cdot \text{Risk}\left(x,y\right)\right\}}$

where λ₁, λ₂, and λ₃ are adjustment coefficients used to balance the trade-offs among classification accuracy, cost efficiency, and risk management. C(Θ) represents the output of customer classification, Var(C(Θ)) is the variance of classification results, used to assess the stability of classifications. The ISCCO framework must satisfy a series of constraints, which can be represented as: (22)${\displaystyle g_k\left(x,y\right)={\left(\sum _{i=1}^n{x}_{ij}-q_j\right)}^2\le 0,\forall j}$ (23)${\displaystyle h_l\left(x,y\right)=\left(\sum _{j=1}^m{x}_{ij}-1\right)=0,\forall i}$

where q_j is the inventory level for the jth type of good, x_ij is the decision variable indicating whether good j is allocated to order i. Based on this, research focuses on minimizing transportation costs. Initially, users are divided into four dimensions based on their sensitivity to product discounts and propensity to cancel orders. This can be achieved through a random forest approach with deep learning feature extraction. The classification model C can be expressed as: (24)${\displaystyle C\left(x\right)=\text{RF}\left(\text{AE}\left(x;W,b\right);\Theta \right)}$

where AE represents the autoencoder used for feature extraction, W, b are the network parameters, RF represents the random forest classifier, Θ is the parameters of the random forest. Based on the classification results from Eq. (24), we further define a goods allocation strategy. This strategy aims to minimize the transportation cost losses incurred from order cancellations. The goods allocation strategy S can be defined by the following expression: (25)${\displaystyle S\left(C\left(x\right),Y;\theta \right)=min\left(\sum _{k=1}^4\sum _{i\in D_k}{w}_i\cdot c_i\cdot \mathbf{1}\left(o_i=\text{cancel}\right)\right)}$

where D_k is the set of orders belonging to the k-th customer class, w_i is the weight of an order, c_i is the cost incurred from cancelling an order, 1 is an indicator function. Our goal is to minimize the total cost L by optimizing the goods allocation strategy S. This optimization problem can be represented as: (26)${\displaystyle \underset{\theta }{min}\left(\sum _{k=1}^4{L}_k\right)=\underset{\theta }{min}\left(\sum _{k=1}^4\sum _{iin{D}_k}{w}_i\cdot c_i\cdot \mathbf{1}\left(o_i=\text{cancel}\right).\right)}$

Here L_k represents the cost loss caused by the k-th class of users. Finally, the optimization of pre-shipped orders allocated to four different dimensions of users can be expressed using the following mathematical formula: (27)${\displaystyle minL=w_1\times L_1+w_2\times L_2+w_3\times L_3+w_4\times L_4}$

where w_k are weights for the k-th class of users, L_k is the predicted cost loss for that class of users, these weights may depend on the order cancellation rate of the class or other business strategy factors.

Algorithm pseudocode and complexity analysis

 
_______________________ 
 Algorithm 1: Optimized Supply Chain Cost Control Algorithm (IS- 
  CCO)                                                                                    _________ 
    Input:   Dataset X  with features on customer purchase 
           behavior and response patterns, Additional order 
           features Y , Initial parameters Θ 
    Output:   Optimized transportation costs L 
    // Feature extraction and customer classification 
 1  Function AutoEncoder(X): 
     2   Encode features to reduce dimensionality and extract 
   nonlinear patterns using Eq. 6 and Eq. 7; 
3   return encoded features h; 
 4  Function RandomForestClassifier(h, ΘRF): 
     5   Classify customers into four categories based on encoded 
   features and sensitivity to discounts and cancellation 
   likelihood using Eq. 8; 
6   return customer categories C(X); 
   // Goods distribution optimization 
 7  Function IntegerLinearProgramming(C(X), Y , ΘILP): 
     8   Optimize goods allocation by minimizing expected cost 
   losses from order cancellations using a genetic 
   algorithm-enhanced ILP model as per Eq. 12 to Eq. 17; 
9   return minimized cost function Z; 
10  Function CostStrategy(C(X), Y , ΘCS): 
     11   Distribute pre-shipped goods to different customer 
   categories to minimize cancellation-related costs using 
   Eq. 23 to Eq. 25; 
12   return updated cost L; 
13  h ← AutoEncoder(X); 
14  C(X)  ← RandomForestClassifier(h, ΘRF); 
15  Y  ← Prepare additional order features; 
16  Z  ← IntegerLinearProgramming(C(X), Y , ΘILP); 
17  L ← CostStrategy(C(X), Y , ΘCS); 
18  return Optimized transportation costs L;    

Considering time complexity, ISCCO is mainly influenced by the number of features, the number of trees, and decision variables, showing potential efficiency in applications with high data complexity. According to Algorithm 1 , the time complexity is $\mathcal{O}\left(n^2+N\cdot logn+m\right)$, involving feature dimension reduction, customer classification, and goods distribution optimization. In terms of space complexity, the algorithm’s space complexity is $\mathcal{O}\left(n^2+N\cdot n+m\right)$, reflecting the space required to store weights for the autoencoder, the structure of the random forest, and the linear programming model.

Comparing the ISCCO framework with other models in the same field, as shown in Table 2, it is evident that the ISCCO framework has a time complexity of $\mathcal{O}\left(n^2+N\cdot logn+m\right)$ and a space complexity of $\mathcal{O}\left(n^2+N\cdot n+m\right)$. Compared to the algorithm by Cao & Liu (2021) (time complexity $\mathcal{O}\left(n^3\right)$, space complexity $\mathcal{O}\left(n^2\right)$), the ISCCO framework can more efficiently utilize computing resources to reduce time costs when handling large-scale data. In terms of space complexity, the ISCCO framework’s complexity is $\mathcal{O}\left(n^2+N\cdot n+m\right)$, which is similar to the algorithm of Sun et al. (2020), but the ISCCO framework may be more efficient for large data sets. The increased space requirement is to support more complex data structures and caching mechanisms, thereby optimizing the execution efficiency and response time of the algorithm.