Hybrid Estimation Method for the State of Charge of Lithium Batteries Using a Temporal Convolutional Network and XGBoost

Abstract

Lithium batteries have recently attracted significant attention as highly promising energy storage devices within the secondary battery industry. However, it is important to note that they may pose safety risks, including the potential for explosions during use. Therefore, achieving stable and safe utilization of these batteries necessitates accurate state-of-charge (SOC) estimation. In this study, we propose a hybrid model combining temporal convolutional network (TCN) and eXtreme gradient boosting (XGBoost) to investigate the nonlinear and evolving characteristics of batteries. The primary goal is to enhance SOC estimation performance by leveraging TCN’s long-effective memory capabilities and XGBoost’s robust generalization abilities. We conducted experiments using datasets from NASA, Oxford, and a vehicle simulator to validate the model’s performance. Additionally, we compared the performance of our model with that of a multilayer neural network, long short-term memory, gated recurrent unit, XGBoost, and TCN. The experimental results confirm that our proposed TCN–XGBoost hybrid model outperforms the other models in SOC estimation across all datasets.

1. Introduction

Lithium batteries have recently attracted considerable attention as the most promising energy storage devices in the secondary battery industry because of their high energy density, long service life, low memory effect, and low self-discharge rate [1,2]. Lithium-ion batteries are widely employed in various fields, including mobile devices, electric vehicles, and energy storage systems. However, these batteries have potential safety risks. In particular, concerns arise owing to their potential to harm human life and damage properties in cases where these batteries explode during usage. The safety problems associated with lithium-ion batteries can be attributed to various factors, with the primary causes being the following [3,4]: (1) battery explosions resulting from overheating; (2) battery explosions caused by overcharging and overdischarging; and (3) battery explosions due to physical damage. Herein, we propose a model for accurately estimating the state of charge (SOC) of batteries to proactively prevent battery explosions caused by overcharging and overdischarging [5,6,7,8]. The state of charge (SOC) of a battery is not a directly measurable parameter; it is defined as the percentage of available capacity remaining in relation to the nominal capacity. Therefore, SOC must be indirectly estimated using an SOC estimation algorithm based on battery parameters obtained from sensor measurements. However, accurately estimating the battery SOC is challenging due to the nonlinear nature of lithium battery parameters and their susceptibility to change based on the operating environment [9,10].

In recent times, numerous researchers have been engaged in exploring SOC estimation methods. These methods can be broadly categorized into three main types: model-based, data-driven, and coulomb counting methods [11]. Model-based methods are known for their robustness and high accuracy, primarily because they are built upon a comprehensive understanding of the system. However, they can face practical and theoretical challenges in creating a flawless model for the target system. On the other hand, data-driven methods do not necessitate practitioners to possess in-depth, specific knowledge of the target system since they rely on data analysis. Nevertheless, they do demand a substantial volume of data for reliable performance. Coulomb counting methods entail measuring a battery’s discharge current and integrating it over time to estimate the current capacity of the battery. In

Table 1. Advantages and disadvantages of model-based, data-driven, and Coulomb counting methods.

Method	Advancements	Limitations	Exemplary Model
Model-based [12,13]	1. Reliability and precision 2. Broad applicability	1. Demands substantial domain expertise 2. Involves a protracted development period	1. Equivalent circuit model 2. Electrochemical model 3. Kalman filter
Data-driven [14,15,16,17,18,19,20,21]	1. Rapid development time 2. Minimal need for specialized knowledge	1. Demands a significant volume of data	1. Neural network 2. Deep learning 3. Look-up table
Coulomb counting [22,23]	Easy to implement	Accumulation of errors occurs over time	Coulomb counting

, we present a summary outlining the advancements and limitations of these three methodological approaches.

In the table, the equivalent circuit model provides an abstract representation of a lithium battery by combining parameters such as resistance, capacitance, and inductance. However, due to its reliance on electrical characteristics, this model falls short of fully elucidating the battery’s internal reactions [24]. In the case of the open-circuit voltage (OCV)–SOC model, SOC estimation relies on modeling SOC based on the battery’s OCV. While this approach is known for its ease of implementation and accuracy, it remains susceptible to uncertainties stemming from factors such as temperature, aging, and driving cycles [25]. In the Coulomb counting model, battery current capacity is estimated using a cumulative current integration method. Although this approach is straightforward to implement, prolonged use may result in the accumulation of measurement errors, leading to a subsequent decrease in accuracy [26]. Within the context of the Kalman filter, it becomes possible to learn and estimate the nonlinear characteristics of a battery in real-time. However, as the predicted state variable increases, computational complexity grows, which in turn extends the calculation times [27]. In the case of neural networks and deep learning models, they acquire knowledge of the relationship between a battery’s capacity and its parameters by analyzing measurements taken directly from the battery. The primary challenge encountered by these models is the accurate capture of the battery’s aging process through the extraction of valuable features from the measured signals [28].

This paper proposes a hybrid estimation method using a temporal convolutional network (TCN) and eXtreme gradient boosting (XGBoost). TCNs and XGBoost are formidable algorithms in the domains of time-series data processing and prediction, respectively, with TCNs excelling at capturing temporal dependencies and XGBoost known for its ability to enhance prediction accuracy. By combining these two algorithms, this study aims to maximize the use of the time-series characteristics of battery data while improving the accuracy of the prediction model. TCNs are primarily employed for extracting temporal patterns, whereas XGBoost serves as a high-performance prediction model. TCNs efficiently extract essential time-series features from input data and, by transmitting these features to the XGBoost model, allow for the separation of feature extraction and prediction. This separation facilitates model interpretability and adjustment. The main contributions of this study are as follows:

• In the TCN part, the long-effective memory feature enables the learning of sequential battery parameters. Additionally, it facilitates the extraction of battery parameter features, enabling the model to learn the changing characteristics of batteries.
• An information layer is employed to interface the TCN part with the XGBoost part. The information layer determines how much past information from the output of the TCN part to incorporate and transforms the output values into a one-dimensional (1D) sequence data format.
• The output of the information layer is used as the input of XGBoost. XGBoost involves learning using a boosting algorithm, and it contributes to reducing errors in the SOC estimated through a strong generalization model. This is confirmed through the experimental results.

The remainder of the paper is organized as follows: Section 2 describes the proposed TCN-XGBoost hybrid model. Section 3 presents the analysis of the experimental results using battery data from NASA, Oxford, and vehicle simulator datasets. Section 4 provides the conclusions.

2. Proposed Lithium Battery SOC Estimation Algorithm Using the TCN-XGBoost Hybrid Model

2.1. TCN

TCN is a neural network architecture designed for processing time-series data. TCN offers notable advantages, particularly when dealing with sequence data that present challenges to traditional architectures, such as recurrent neural networks. The key characteristics of TCN can be summarized as follows [29,30]. First, TCN employs causal convolution, which ensures that information from the future is not leaked into the past. This design choice is crucial for time-series data, as it restricts the model to using only past time steps for predictions. In addition, TCN leverages dilated convolutions, allowing it to capture information from a wide range of input positions effectively. This enables the model to learn long-term dependencies and detect extended patterns within sequence data. Finally, TCN is known for its efficiency, offering a lighter model compared to architectures like WaveNet. Achieving this efficiency involves the removal of some connections and gate activations.

The TCN receives the input ($x_0$, …, $x_t$) and predicts the output ($y_0$, …, $y_t$) corresponding to each time. The key constraint is that to predict the output $y_t$ for some time $t$, only the present and past inputs are used.

The sequence modeling network is shown through the following equation:

$${\widehat{y}}_0,...,{\widehat{y}}_t=f(x_{0 },...,x_{t }).$$

(1)

The TCN operates based on two key principles: (1) the network generates outputs of the same length as the input, and (2) it maintains a causal characteristic that prevents information leakage from the future to the past. In practical terms, this means that during the convolution operation, the output at time step $t$ is convolved with elements from both time step $t$ and the previous time step.

In order to meet the first characteristic, the TCN utilizes a 1D fully convolutional network (FCN), where the output hidden layer matches the length of the input hidden layer. To achieve this consistency, zero padding is applied using the kernel size −1 to retain the same length as the preceding layer. To satisfy the second causal characteristic, the TCN uses a causal convolution operation in which the convolution operation at the time $t$ only comprises the time $t$ of the previous layer and the time points before it. In other words, TCN = 1D FCN + causal convolutions.

The basic design of the TCN, comprising only FCN and causal conventions, has the disadvantage of using a very deep network or a large filter size to obtain a long-effective history in a long sequence. A dilated convolution is added to solve this problem.

Dilated convolution refers to a method of minimizing the amount of computation while increasing the receptive field. In simple convolution, deep layers are limited in creating large receptive fields, making it difficult to deal with sequence data affected in the distant past. On the contrary, dilated convolution makes it possible to increase exponentially according to the depth of the layer. More formally, for a 1D sequence input $x\in {\mathbb{R}}^n$ and a filter $f:\{0,\dots , k-1\}\to \mathbb{R}$, dilated convolution is defined as follows:

$$F\left(s\right)=\left(x\ast {}_{d}f\right)\left(s\right)={\sum }_{i=0}^{k-1}f\left(i\right)·x_{s-d·i},$$

(2)

where $s$ is the sequence, $d$ is the dilation factor, and $k$ is the filter size. In the context of convolution, s − d … i indicates shifting the filter by s − d … i units for each element s of the input sequence. This effectively indicates that dilation is akin to inserting a fixed length between adjacent filter elements. When d = 1, it corresponds to standard convolution, while increasing d allows for representing a considerably broader range of the input. The receptive field of the TCN can be extended by increasing the filter size $k$ and the dilation factor $d$ or by extending the network depth. In the TCN, the dilation factor $d$ exponentially increases with the layer depth. This is illustrated in Figure 1.

A residual connection is applied to every layer for stable training of the deep layers of the TCN. Figure 2 presents the residual block. The residual block includes dilated convolution layers with the same dilation factor $d$, ReLU, and dropout. At this time, the channel width of the input and the output may be different, so 1 × 1 convolution is applied to the input to match the channel width. The output of the residual block is shown in the following equation:

$$o=Activation(x+F\left(x\right)).$$

(3)

2.2. XGBoost

XGBoost is a decision tree-based ensemble machine learning algorithm that uses the gradient boosting framework. Gradient boosting is a supervised learning algorithm that uses a gradient to sequentially fit new models that compensate for the weaknesses of previous models and then linearly combine them to generate models. However, gradient boosting can cause overfitting when there is noise. XGBoost adds the parameters γ and λ to prevent the overfitting problem of gradient boosting [31,32].

XGBoost uses advanced regularization to improve its model generalization capability. Herein, the characteristics of XGBoost were combined with the TCN output.

XGBoost uses a classification and regression tree (CART) model. CART represents one value, where each node represents each dataset. The XGBoost algorithm is as follows. First, the initial model is set as a constant, as shown in the following equation:

$${\widehat{y}}_i=\varphi \left(o_i\right)=\sum _{k=1}^K{f}_k(o_i), { f}_k\in \mathcal{F},$$

(4)

where $\mathcal{F}$ is the space of the regression trees, $K$ is the number of CARTs, $y_i$ is the predicted value of $o_i$, and $o_i$ is the output of the TCN layer. The objective function for training each CART model is shown in the following equation:

$$obj\left(\theta \right)={\sum }_i^{n}l(y_i,{\widehat{y}}_i)+{\sum }_{k=1}^K\Omega \left(f_k\right),$$

(5)

where the left term represents the training loss, which is the difference between the actual and predicted values, while the right term serves as a regularization term to control the complexity of the tree model and prevent overfitting. $l(y_i,{\widehat{y}}_i)$ is the objective function calculated from the target value $y_i$ and the predicted value ${\widehat{y}}_i$, and $\Omega$ is the normalization function of the model to prevent overfitting. The parameters to be learned are the structure of each tree and the scores of the leaf nodes, represented as $\theta$ = $f_1$, $f_2$,…, $f_k$.

In Equation (5), $f$ contains the structure of the tree and the predicted value of the node. It is impossible to train all the trees at once. XGBoost adds a model that predicts unexpected parts in all steps at each step. The new objective function (e.g., at step t) takes the form of an expansion represented by Taylor’s theorem, generally including up to the second order, as follows:

$${obj}^{\left(t\right)}={\sum }_{i=1}^n\left[g_i{f}_t\left(o_i\right)+\frac{1}{2}{h}_i{f_t}^2\left(o_i\right)+\Omega \left(f_t\right)\right],$$

(6)

where $g_i$ and $h_i$ are the primary and secondary partial differential values, respectively. The model complexity of XGBoost is shown in the following equation:

$${obj}^{\left(t\right)}={\sum }_{i=1}^n\Omega \left(f\right)=\gamma T+\frac{1}{2}\lambda {\sum }_{j=1}^T{{\omega }^2}_j,$$

(7)

where $\omega$ represents a vector for node scores and $T$ represents the number of nodes. $\gamma T$ represents the number of leaves, adjusting the complexity of the model in relation to its accuracy. $\frac{1}{2}\lambda {\sum }_{j=1}^T{{\omega }^2}_j$ is the L2 norm function of the leaf scores.

2.3. Proposed TCN-XGBoost Hybrid Model

The SOC of lithium batteries changes under the influence of their characteristics, degradation, and operating environment. To improve the SOC estimation accuracy, considering internal and external factors, the estimation model must model the important characteristics of the battery parameters. Therefore, we designed a TCN-XGBoost hybrid model.

This hybrid model was designed to accurately estimate the SOC by receiving the internal parameters of a battery as sequence data from the TCN, extracting the characteristics of the data, and increasing the generalization performance by inputting the characteristics of the data into XGBoost. The structure of the proposed model is presented in Figure 3.

The battery parameters used as input to the proposed model using the NASA and Oxford datasets were discharge voltage, current, operation time, and temperature, while those using the vehicle simulator dataset were the discharge voltage of each cell, current, battery pack voltage, operation time, and temperature. The information layer transforms the output values of TCN into an input form for XGBoost. In the information layer, $o_1$, …, $o_n$ represents the output values of TCN containing past information.

This model progresses through data preprocessing, feature extraction, past information usage, and generalization. Data preprocessing involves processing the dataset to standardize it and transform it into the appropriate format for input. Feature extraction uses residual blocks with dilated causal convolutions in TCN to extract features from the data using information from both the past and present, thereby creating long-effective memory features. To transmit the information from both past and present data from the output of TCN to the input of XGBoost, an information layer is defined. The information layer is responsible for configuring the number of input parameters when passing the output of the TCN to the XGBoost model and converting the 2D output of the TCN into a 1D format suitable for XGBoost input. The reason for configuring the number of input parameters is to enhance the prediction accuracy of XGBoost using the current input, including past information, as the input for XGBoost. In other words, if the information layer has two nodes, $o_{n-2}$, $o_{n-1}$, and $o_n$ are used as input to XGBoost when making predictions. Through the boosting algorithm, XGBoost sequentially trains multiple weak learners. By assigning weights to incorrectly predicted data and iteratively updating these weights, the weak learners are progressively strengthened, culminating in the formation of a final predictor, resulting in a more generalized and robust model. Subsequently, XGBoost estimates the SOC and outputs the result. Generalization involves transmitting the data from the information layer to XGBoost. Subsequently, XGBoost estimates the SOC and outputs the result.

Our battery SOC estimation process based on the proposed model is as follows:

• To use the battery data as input to the proposed model, the data were set in sequence. Voltage, current, temperature, and operation time were used as input parameters.
• The input data were used as the input for TCN, and the output of TCN was obtained using the dilated convolution operation in Equation (2) and the activation function in Equation (3). Herein, the ReLU function was used as the activation function.
• The information layer determines how much past information from the output of TCN to use. For instance, if n pieces of past information are chosen, the sequential data $o_1$, $o_2$, …, $o_{n-1}$, $o_n$ are used as inputs for the subsequent XGBoost model.
• The information layer transfers the data to XGBoost, and XGBoost ultimately estimates the SOC based on Equation (7).

3. Experiments and Results

In this study, the proposed model’s performance was evaluated through training on datasets from NASA, Oxford, and a vehicle simulator. The training was conducted on a computer equipped with a The AMD Ryzen 5600X processor from the United States, California, an The NVIDIA RTX 3070 graphics card from the United States, California, and 16 GB of RAM, using Python 3.6, TensorFlow 2.2, and the Keras library.

In the conducted experiments, a multilayer neural network (MNN) [33], long short-term memory (LSTM) [34], a gated recurrent unit (GRU) [35], XGBoost, and a temporal convolutional network (TCN) were employed to assess their performance in comparison to the proposed hybrid TCN-XGBoost model. The hyperparameters for each model used in the experiments are provided in

Table 2. Hyperparameter settings for each model used in the experiments.

Model	Hyperparameter	Value
TCN	nb_filter	128
	kernal_size	3
	nb_stack	2
	deliations	[1,2,4,8,16,32]
	padding	Causal
	use_skip_conections	Ture
XGBoost	n_estimators	1000
	max_depth	5
	gamma	0
	reg_alpha	0
	reg_lamda	1
	subsample	0.75
	learning rate	0.001
MNN	hidden layer, one node	64
	hidden layer, two nodes	32
	learning rate	0.01
LSTM	LSTM layer, one node	32
	LSTM layer, two nodes	16
	learning rate	0.01
GRU	GRU layer, one node	32
	GRU layer, two nodes	16
	learning rate	0.01

.

For the TCN model in Table 2, nb_filter is the number of filters to use in the convolutional layers, kernal_size is the size of the kernel to use in each convolutional layer, nb_stack is the number of stacks of residual blocks to use, dilations is a dilation list, padding is the padding to use in the convolution, “causal” means a causal network, and use_skip_connections is the setting to add skip connections from the input to each residual block.

In the XGBoost model, ‘n_estimators’ represents the number of gradient-boosted trees, ‘max_depth’ is the maximum tree depth for base learners, ‘gamma’ signifies the minimum loss reduction required to initiate an additional partition on a leaf node of the tree, ‘reg_alpha’ and ‘reg_lambda’ denote L1 and L2 regularization terms applied to weights, and ‘subsample’ stands for the subsample ratio of the training instances.

The experiments used battery data provided by the NASA Ames Research Center and Oxford. NASA’s battery dataset includes periodic charge and discharge cycles using lithium-ion 18650 batteries. These experiments yielded information on temperature, load voltage, current, and time. Charging was conducted at a constant current of 1.5 A until the battery voltage reached 4.2 V, while discharging proceeded at a constant current of 740 mA until reaching 2.7 V. Herein, data from Battery #5 were used. Oxford’s dataset includes periodic charge and discharge experiments using small lithium-ion pouch cells in a 40 °C environment, performed at constant current and constant voltage. In this study, data from Battery Cell 1 were used. The vehicle simulator dataset was generated by serially connecting eight lithium-ion 18650 battery cells and conducting discharge experiments using a vehicle simulator. This vehicle simulator was based on the The Hyundai Motor-manufactured Avante Sports AD 16 vehicle produced in Ulsan, South Koreaand was custom-built to match the wheel size and motor RPM specifications for the experiments. The vehicle simulator operated in FTP-75 mode, and the experiments continued until the battery pack was fully discharged. For the NASA dataset, the B0005 battery dataset was used, and a total of 6 and 144 cycles were used for the tests and learning, respectively. The Cell 2 battery dataset from the Oxford dataset was utilized, with a total of 6 cycles for testing and 71 cycles for training. In the case of the vehicle simulator dataset, 1 cycle was used for testing, and 10 cycles were used for training. The experimental data is visualized in Figure 4, Figure 5 and Figure 6.

The error was calculated using the mean absolute error, which is shown in the following equation:

$$MAE=\frac{1}{n}{\sum }_{i=1}^n\left|y_i-\widehat{y}\right|,$$

(8)

where $n$ is the total number of parameters, $y_i$ is the target value, and $\widehat{y}$ is the estimated value.

The experimental results obtained for each model using the NASA dataset are presented in

Table 3. SOC estimation results of each model for the mean absolute error using the NASA dataset.

	41 Cycle	63 Cycle	78 Cycle	100 Cycle	125 Cycle	150 Cycle	Average
MNN	0.076	0.101	0.083	0.136	0.115	0.334	0.1408
LSTM	0.09	0.141	0.096	0.103	0.126	0.222	0.1296
GRU	0.185	0.084	0.131	0.134	0.066	0.188	0.1313
XGBoost	0.176	0.097	0.083	0.093	0.088	0.228	0.1275
TCN	0.126	0.117	0.125	0.105	0.098	0.197	0.128
TCN-XGBoost (one node)	0.112	0.081	0.093	0.078	0.067	0.172	0.1005
TCN-XGBoost (two nodes)	0.093	0.080	0.094	0.081	0.063	0.162	0.0955

. The mean absolute errors (MAEs) for MNN, LSTM, and GRU are 0.1408, 0.1296, and 0.1313, respectively. XGBoost and TCN exhibit MAEs of 0.1275 and 0.128, respectively, while TCN-XGBoost (one node) and TCN-XGBoost (two nodes) demonstrate MAEs of 0.1005 and 0.0955, respectively. The evaluation revealed that the SOC estimation by the proposed TCN-XGBoost hybrid model outperformed those by other models for 150 cycles, representing the battery test dataset under degraded conditions. Additionally, for the remaining NASA test dataset, the proposed model exhibited greater accuracy compared to the other models.

Figure 7 shows the SOC estimation results of each model used in the experiments and the results for 150 cycles using the NASA dataset. The upper graph presents the estimation results of the model, and the lower graph presents its estimation error.

The experimental results obtained using the Oxford dataset indicate that the MAEs for MNN, LSTM, and GRU are 0.2105, 0.1563, and 0.1253, respectively (

Table 4. SOC estimation results of each model for the mean absolute error using the Oxford dataset.

	6 Cycle	15 Cycle	28 Cycle	42 Cycle	70 Cycle	78 Cycle	Average
MNN	0.303	0.205	0.164	0.191	0.167	0.233	0.2105
LSTM	0.269	0.088	0.145	0.182	0.122	0.132	0.1563
GRU	0.21	0.103	0.115	0.132	0.095	0.097	0.1253
XGBoost	0.102	0.126	0.198	0.119	0.146	0.161	0.142
TCN	0.163	0.12	0.203	0.161	0.222	0.191	0.1767
TCN-XGBoost (one node)	0.116	0.045	0.135	0.092	0.123	0.091	0.1003
TCN-XGBoost (two nodes)	0.113	0.049	0.134	0.090	0.110	0.094	0.0983

). XGBoost and TCN exhibit MAEs of 0.142 and 0.1767, while TCN-XGBoost (one node) and TCN-XGBoost (two nodes) demonstrate average estimation errors of 0.1003 and 0.0983, respectively. The proposed TCN-XGBoost hybrid model, incorporating the information layer, achieves an MAE of 0.0983. When comparing the proposed model to MNN, the difference in MAE is 0.112. Notably, the error is lower than that of the existing TCN and XGBoost models, indicating good estimation performance of the TCN-XGBoost model with the information layer when using the Oxford dataset. Figure 8 depicts the SOC estimation results of each model employed in the experiments and the results for 78 cycles using the Oxford dataset.

Table 5. Results of each model for the SOC estimation error using the vehicle simulator dataset.

	Cell 1	Cell 2	Cell 3	Cell 4	Cell 5	Cell 6	Cell 7	Cell 8	Average
MNN	3.173	1.36	1.154	2.772	1.989	1.008	1.862	1.545	1.857
LSTM	2.616	1.137	0.74	2.387	1.909	1.035	1.877	1.297	1.624
GRU	2.685	1.035	0.772	2.62	1.731	1.08	1.933	1.331	1.648
XGBoost	1.235	1.219	0.745	2.36	1.699	0.991	1.686	1.715	1.456
TCN	0.957	1.219	0.934	2.253	1.604	0.95	1.797	1.428	1.393
TCN-XGBoost (one node)	1.143	1.14	0.938	2.333	1.598	1.028	1.712	1.514	1.413
TCN-XGBoost (two nodes)	1.121	1.114	0.937	2.212	1.569	1.011	1.667	1.459	1.386
TCN-XGBoost (three nodes)	1.107	1.127	0.92	2.211	1.57	0.997	1.672	1.441	1.381

presents the results obtained from experiments conducted using the vehicle simulator dataset. MNN, LSTM, and GRU demonstrate MAEs of 1.857, 1.624, and 1.648, respectively. XGBoost and TCN exhibit MAEs of 1.456 and 1.393, while TCN-XGBoost (one node), TCN-XGBoost (two nodes), and TCN-XGBoost (three nodes) achieve MAEs of 1.413, 1.386, and 1.381, respectively. Despite the frequent data fluctuations in the vehicle simulator dataset, the proposed model outperforms the other models. Figure 9 depicts the SOC estimation results for each model used in the experiments and the results for cell 7 using the vehicle simulator dataset.

To validate the performance of our proposed model, we compared its results with those of other battery SOC estimation studies [36,37] that used data from Battery #5 in the NASA dataset. Zhang et al. [36] proposed an SOH–SOC simultaneous estimation model based on the GWO-BP neural network. The algorithm in [36] exhibited an average SOC estimation error within 5%. The model presented in our paper demonstrates battery SOC estimation with an accuracy of <1%, indicating its ease of use compared to BP-based models [36]. Furthermore, Li et al. [37] estimated battery SOC using the FCNN, 2DCNN, and 3DCNN models based on CNN. Among the proposed models, FCNN achieved the best performance, with a MAE of 0.4694. The model proposed in this paper shows easy battery SOC estimation, with an MAE of 0.095.

4. Conclusions

This paper proposes a hybrid TCN-XGBoost model for estimating the SOC of lithium batteries. The proposed model integrates a TCN with long-effective memory features, leverages XGBoost for enhanced estimation performance, and incorporates an information layer to use past information as the next input. Within this framework, the TCN extracts data features, while the information layer sequentially transforms past information into a 1D matrix. XGBoost is employed to optimize the model structure to effectively align it with the extracted features. Experimental results validate that the proposed model effectively captures battery SOC characteristics, resulting in improved estimation accuracy.

For the validation of the proposed model, MNN, LSTM, and GRU were employed. TCN and XGBoost were also used to compare the performance of single and hybrid models. Furthermore, to validate the proposed model across diverse battery characteristics, battery data from the NASA, Oxford, and vehicle simulator datasets were employed. Experimental results indicate that the proposed model outperformed the other models, with MAEs of 0.095, 0.0983, and 1.381 using the NASA, Oxford, and vehicle simulator test datasets, respectively, confirming its superior estimation performance. Moreover, the proposed model exhibited superior estimation performance to single models, underscoring the effectiveness of the model.

In future research, we plan to apply the proposed model to a real-world environment to evaluate its practical utility.