Insurance claims estimation and fraud detection

Full text

Turn on search term navigation

Introduction

Insurance fraud detection addresses a significant challenge in the industry, where fraudulent claims cause great financial losses every year. The claims are usually exaggerated, falsified, or intentionally misrepresented. This interrupts the smooth running of business and increases premiums for policyholders. This detection of fraud requires the identification of irregular patterns or anomalies in claims data-which might prove complex on account of sheer volume or the permutations applied in attempting to defraud. Traditional approaches and techniques have proven inadequate in handling such scales and sophistication of modern fraud cases¹.

The advanced techniques of artificial intelligence, especially deep learning, have enhanced the detection process. Deep learning models examine large volumes of data to identify sophisticated and hidden patterns indicating fraud. Due to the utilization of historical claims data together with other factors such as demographics, claim history, and behavioural trends, these models improve accuracy and operational efficiency. The adaptability of these techniques into changing data environments and fraud tactics ensures a strong and proactive course of action for fraud detection, which can minimize financial loss and enhance decision-making processes².

Deep learning models are particularly suitable for tasks like estimation of insurance claims and fraud detection, where the data is both complex and high-dimensional. Traditional statistical methods have the ability to capture intricate relationships and patterns embedded in large, unstructured datasets. In contrast, multi-layered neural architectures are perfect for processing huge volumes of data, inferring the presence of hidden patterns, and generating highly accurate predictions. These models allow for advanced feature extraction as well as representation learning, avoiding intense handcrafted feature engineering, and thus simplifying the analysis of complex datasets³.

In dynamic domains such as the insurance industry, characteristics of data change regularly. Deep learning models are adaptive learning from new data to remain valid and accurate in the long run. These models might be able to discover minor anomalies and patterns that are typical symptoms of fraudulent behavior, which might even not be identified by more standard approaches. The scalability process diverse data types, including numerical, categorical, and textual information enhance the applicability, making the model indispensable for tasks requiring precision and adaptability in data-driven decision-making⁴.

Several advanced models have been developed for fraud detection, applying machine learning and deep learning techniques to increase accuracy and efficiency. Because the capability of capturing non-linear relationships in the data and the efficiency of Gradient Boosting Machines (GBM) while handling structured data along with its variants such as XGBoost, LightGBM, and CatBoost. Additionally, Support Vector Machines (SVM) and Random Forests (RF) have been prominent and give robust performance on the imbalanced datasets that normally apply to fraud detection. Among neural architectures, Feed-Forward Neural Networks (FFNN) and Autoencoders have proven to have strengths in anomaly detection performing as unsupervised detection tools to identify peculiar trends in the claims data⁵.

Deep learning models designed for specific fraud detection include Convolutional Neural Networks (CNN) for image-based data. Recurrent Neural Networks (RNN) and Long Short-Term Memory (LSTM) networks are used in sequential data such as timelines of transactions to detect the anomalies. More complex architectures like Graph Neural Networks (GNN) are considered in the interest of the efficiency to analyze relationships in graph-structured data such as the connection between policyholders and claims. Such hybrid models, combining techniques like attention mechanisms with LSTMs and decision trees integrated with neural networks, become state-of-the-art solutions and obtain much better performance in discovering complex and evolving patterns of fraud⁶.

Fraud detection in insurance claims is a critical task in the insurance industry, as fraudulent activities can lead to significant financial losses. While traditional machine learning models and deep learning architectures have shown promise in detecting fraudulent claims, existing methods often face challenges in efficiently handling high-dimensional and complex datasets. Specifically, many models struggle with issues such as slow convergence, getting trapped in local minima, and suboptimal hyperparameter tuning, which leads to subpar performance in real-world applications. Insurance claims estimation and fraud detection systems that employ deep learning face ongoing challenges because of slow convergence, local minima problems and a lack of sufficient hyperparameter optimization. Modern insurance systems frequently encounter difficulties with CNNs and VGG and ResNet when used together because they need extensive fine-tuning to achieve convergence.

The research gap addressed by this study lies in optimizing the performance of deep learning models for fraud detection. Existing models, such as CNNs, often require extensive manual tuning and fail to fully exploit optimization techniques that could enhance their convergence speed and accuracy. In particular, the lack of effective hyperparameter optimization and the inability to overcome local minima limits the models’ performance, especially when dealing with large and complex datasets.

The proposed EHOA-CNN-12 model introduces the Enhanced Hippopotamus Optimization Algorithm (EHOA) alongside a specially designed 12-layer CNN architecture to address these issues. By optimizing the hyperparameters dynamically and overcoming local minima, the EHOA-CNN-12 model achieves faster convergence, improved accuracy, and greater robustness. This solution provides a significant improvement over existing deep learning models in terms of both efficiency and performance, making it well-suited for real-world fraud detection in insurance claims.

To evaluate the performance of the proposed EHOA-CNN-12 model for fraud detection in insurance claims, it is compared with several well-established deep learning architectures: VGG16, VGG19, ResNet50, Custom CNN-12, and Custom CNN-15. These models were selected based on their architectural diversity, ability to process image-based data, and relevance to fraud detection in insurance claims. Each model has shown effectiveness in various image classification tasks, making them strong candidates for this study.

VGG16 and VGG19: These models are recognized for their simplicity and depth, differing mainly in the number of layers (16 and 19, respectively). They are commonly used as benchmarks in image classification tasks and provide a foundation for assessing the impact of deeper networks in fraud detection applications.
ResNet50: ResNet50 is a deep residual network that uses skip connections to overcome issues like vanishing gradients, enabling the training of deeper networks without performance degradation. Its design makes it particularly suited for handling complex, high-dimensional datasets such as those used in this study.
Custom CNN-12 and Custom CNN-15: These custom models were designed to evaluate simpler, less computationally demanding architectures. By adjusting the number of layers, these models facilitate exploration of the balance between model complexity and performance in insurance fraud detection.

The selection of models for comparison spans a wide range of depths and complexities, ensuring a comprehensive evaluation of the proposed EHOA-CNN-12 model’s performance relative to existing deep learning solutions.

The main contributions of the proposed work are listed below.

Enhanced Hippopotamus Optimization Algorithm (EHOA) is proposed to optimize hyperparameters in the custom CNN model to improve the overall performance.
Development and integration of a Custom CNN architecture of 12 layers built to accurately perform insurance claims estimation and fraud detection.
Implementation of a multi-resolution stage CNN approach processes data at differing resolutions and improving both detection accuracy and processing speed.
It achieves great improvements in model accuracy and efficiency by using EHOA. It encounters problems such as local minima and slow convergence.
The proposed EHOA-CNN model outperforms than existing state-of-the-art methods in performing the tasks of insurance claims estimation and fraud detection.

While the EHOA-CNN-12 model demonstrates significant improvements in performance for fraud detection in insurance claims, it is important to consider the challenges associated with its real-world applicability, especially for deployment in operational environments. Although the model excels in terms of computational efficiency and accuracy during training, several additional factors must be addressed for practical deployment. These include computational resource requirements, model interpretability, and seamless integration with existing fraud detection systems. Overcoming these challenges will be essential to ensure that the model can be effectively adopted and utilized in real-world fraud detection workflows.

Section “Related works” explains the various state of art models exist and the comparative analysis with other state of art models. Section “Methodology” discusses the various models architecture like VGG16, VGG19, ResNet50, custom 12-layer, and custom 15-layer and the proposed EHOA-CNN-12. Section “Results and Discussion” presents the experimental results, and Sect. “Conclusion” concludes the study with future directions.

Related works

Hong et al. (2024) proposed a multi-channel heterogeneous graph structure learning approach to detect health insurance fraud. In this work, diverse graph-based features from different claims to capture complex relationships and patterns for increasing better accuracy in fraud detection. This robust fraud-detecting model due to the ability of integrating multiple sources of data and processing diverse fraud indicators could be a valuable tool in healthcare fraud prevention⁷. Schrijver et al. (2024) presents a systematic review of data mining techniques applied in automobile insurance fraud detection. Several methods such as classification algorithms and clustering, most applied to identify the fraudulent claims and the effectiveness of every approach in improving fraud detection⁸. Vorobyev, (2024) proposed graph features for fraud risk assessment in car insurance. The machine learning models are used for suspicious pattern detection from claim data and assessing the probability of fraud toward increasing the detection of fraudulent activities in car insurance⁹. Sahu et al. (2024) integrates blockchain and machine learning to develop a secure driver behaviour-centric insurance model for electric vehicles. The model involves using blockchain to ensure integrity and transparency in data while using machine learning to detect fraudulent claims based on the behavior of the driver. This intends to make insurance models for electric vehicles both more secure and efficient¹⁰.

Farbmacher et al. (2022) introduces an Explainable Attention Network (EAN) is designed for the detection of fraud in claims management. The EAN model makes clear decisions as it emphasizes the most critical features of fraudulent behavior inside claims data. It explicitly stresses interpretability, considered to be a most necessary requirement for earning trust in automated fraud detection systems¹¹. Nian et al. (2016) discusses unsupervised spectral ranking for identifying anomalies in auto insurance fraud. It uses spectral ranking methods to identify abnormal claims behavior in the absence of labeled data. The method has been beneficial in finding latent patterns of fraud within large and unstructured insurance datasets¹². Kalra et al. (2022) explores fuzzy expert systems can be used to predict and detect fraud in healthcare insurance. Fuzzy techniques of logic are used to address uncertainties in the given insurance data by making it possible to use flexible and more accurate methods to improve the outcome of fraud detection, where data is incomplete or vague¹³.

Habibpour et al. (2023) introduces an uncertainty aware deep learning model to detect credit card fraud. It incorporates uncertainty estimation for better discovery of fraudulent transactions, especially in cases where traditional methods experience difficulties when unsure or borderline fraudulent activity occurs¹⁴. Innan et al. (2024) assesses the quantum models of machine learning for financial fraud detection. It compares with the traditional method of classical machine learning technique to check their ability to detect fraud more efficiently. It shows the promising capability of quantum models in performing large fraud detection tasks¹⁵. Šubelj et al. (2011) proposes an expert system that uses the social network analysis method to detect automobile insurance fraud. By analyzing the relationships and interactions between people within the claims data and the system seeks to reveal patterns that could be suspicious and fraudulent¹⁶. Mosa et al. (2024) presents a Credit Card Fraud Detection system (CCFD) using meta-heuristic techniques together with machine learning algorithms. In this method, feature selection and model parameter optimization, through meta-heuristics such as genetic algorithms and simulated annealing helps to enhance the accuracy of the detection of fraud¹⁷.

Akhavan and Hassannayebi (2024) develop a hybrid machine learning process analytics model to predict customer experience in the online services industry of insurance. Predictive analytics and process optimization techniques are used by the authors to improve customer satisfaction and reduce fraudulent claims through key factors which affect fraud risk¹⁸. Adil, et al. (2024) describes an optimized deep event-based network framework aimed at credit card fraud detection. Optimizing the deep models improves the chances of identifying fraudulent transactions by utilizing the temporal and event-driven feature variants in the transactional data¹⁹. Kumaraswamy et al. (2024) utilizes Bayesian Belief Network (BBN) to detect healthcare frauds. The BBN model takes uncertainties in claims data into account and consequently allows the system to draw probabilistic inferences about the fraud. This approach is directed toward maximizing the accuracy level of fraud detection in healthcare insurance²⁰. Dimri et al. (2022) proposed a multi-input multi-label claims channeling system using insurance-based language models. In this system, the Natural Language Processing (NLP) model analyzes claims data and extracts the relevant features for fraudulent claim identification across multiple insurance channels²¹.

Sundarkumar and Ravi (2015) presents a novel hybrid undersampling method for dealing with imbalanced datasets in banking/insurance fraud detection. The method improves detection of fraudulent transactions by adequately balancing the dataset and enhancing the performance of the learning models²². Li et al. (2018) proposes a Principal Component Analysis (PCA) based random forest model for automobile insurance fraud detection. The model integrates PCA to reduce dimensionality and improve the performance of random forest classifiers in identifying fraudulent claims in automobile insurance data²³. Jena et al. (2024) introduces advanced blockchain-based solution using Hyperledger Fabric for tracing the fraudulent claims in the healthcare industry. Blockchain technology is designed to ensure transparency, data integrity, and traceability with the help of which fraudulent activities in healthcare insurance can be detected and prevented effectively²⁴. Islam et al. (2024) presents a rule-based machine learning model for financial fraud detection. The model combines traditional rule-based systems with machine learning algorithms in order to improve the accuracy of fraud detection while reducing false positives in financial transactions²⁵.

Sorour et al. (2024) uses the Brown Bear Optimization algorithm for credit card fraud detection. This optimization algorithm is used to enhance the feature selection process and improve the performance of the machine learning models for the identification of fraudulent credit card transactions²⁶. Gu et al. (2024) presents a negative selection algorithm with hypercube interface detectors to detect anomalies. The focus is on the detection of fraudulent activities where anomalies are detected in the transaction data using some novel detection mechanism based on hypercube interfaces²⁷. Chhabra et al. (2024) detects credit card fraud using a voting ensemble machine learning approach in highly imbalanced datasets. The ensemble method of multiple models aggregates models that improve the accuracy and robustness of the algorithm for detecting fraudulent transactions, especially when fewer such transactions occur compared to the majority of legitimate ones²⁸. No et al. (2024) focuses on training-free retrieval-based log anomaly detection with pre-trained language models. The proposed method does not require model retraining, depends only on pre-training models to detect anomalies within logs, especially useful for fraud detection in log-based systems²⁹. Cherif et al. (2024) proposes an encoder-decoder graph neural network for credit card fraud detection. The approach utilizes a graph-based architecture to describe relationships among transaction events and leverages deep learning to detect fraud³⁰. The comparative analyses of the models are given in Table 1.

Table 1. Comparative analysis of the models in insurance fraud detection.

S.No	Author(s) (Year)	Dataset	Methodology	Adv & Disadv
1.	Hong et al. (2024)	Multi-channel heterogeneous graph	Multi-channel graph learning for fraud detection	Adv: Multi-channel integration; Disadv: Complex model
2.	Schrijver et al. (2024)	Various automobile datasets	Systematic review of data mining techniques	Adv: Comprehensive review; Disadv: No novel methods
3.	Vorobyev (2024)	Claims graph features	Machine learning with claims graph features	Adv: Effective fraud detection; Disadv: Limited to claims data
4.	Sahu et al. (2024)	Electric vehicle insurance data	Blockchain & machine learning integration	Adv: Secure model; Disadv: Requires blockchain integration
5.	Farbmacher et al. (2022)	Claims data	Explainable attention network for fraud detection	Adv: Interpretability; Disadv: Complex model
6.	Nian et al. (2016)	Auto insurance claims	Unsupervised spectral ranking for anomaly detection	Adv: Unsupervised learning; Disadv: Limited to anomalies
7.	Kalra et al. (2022)	Healthcare insurance	Fuzzy expert systems for fraud detection	Adv: Flexible model; Disadv: Can be computationally expensive
8.	Habibpour et al. (2023)	Credit card data	Deep learning for fraud detection	Adv: Uncertainty-aware; Disadv: Complex deep learning approach
9.	Innan et al. (2024)	Financial fraud datasets	Quantum machine learning models	Adv: Advanced approach; Disadv: Requires quantum computing resources
10.	Šubelj et al. (2011)	Automobile insurance data	Social network analysis for fraud detection	Adv: Novel use of social networks; Disadv: Data sparsity
11.	Mosa et al. (2024)	Credit card data	Meta-heuristics & machine learning	Adv: Efficient detection; Disadv: Requires meta-heuristics
12.	Akhavan & Hassannayebi (2024)	Customer experience data	Hybrid machine learning & process analytics	Adv: Predicts customer experience; Disadv: Complex integration
13.	Adil et al. (2024)	Credit card data	Optimized deep event-based network	Adv: Optimized detection; Disadv: Needs deep learning expertise
14.	Kumaraswamy et al. (2024)	Healthcare claims	Bayesian Belief Network for fraud detection	Adv: Probabilistic approach; Disadv: Complex for large datasets
15.	Dimri et al. (2022)	Claims data	Multi-input multi-label system	Adv: Multiple input handling; Disadv: High computational cost
16.	Sundarkumar & Ravi (2015)	Banking & insurance data	Hybrid undersampling for unbalanced data	Adv: Handles imbalanced data; Disadv: May lose valuable data
17.	Li et al. (2018)	Automobile insurance claims	PCA-based random forest with nearest neighbor	Adv: Simple, effective; Disadv: Limited feature selection
18.	Jena et al. (2024)	Healthcare claims	Blockchain-based fraud tracing	Adv: Secure; Disadv: Needs blockchain expertise
19.	Islam et al. (2024)	Financial fraud data	Rule-based machine learning model	Adv: Simple, interpretable; Disadv: May lack accuracy
20.	Sorour et al. (2024)	Credit card data	Brown bear optimization algorithm	Adv: Nature-inspired optimization; Disadv: Not well-known
21.	Gu et al. (2024)	Anomaly detection	Negative selection algorithm with hypercube detectors	Adv: Effective for anomalies; Disadv: Complex approach
22.	Chhabra et al. (2024)	Credit card fraud data	Voting ensemble learning model	Adv: Combines multiple models; Disadv: High computation cost
23.	No et al. (2024)	Log data	Pre-trained language model for anomaly detection	Adv: Training-free; Disadv: Token-level issues
24.	Cherif et al. (2024)	Credit card data	Encoder-decoder graph neural network	Adv: Powerful graph learning; Disadv: High computational cost

Research gap analysis

Fraud detection in insurance and financial services sectors shows significant progress towards using machine learning, deep learning, and hybrid methodologies. However, there are many gaps across the studies reviewed. First, promising trends exist towards models that incorporate multi-channel integration, blockchain, and quantum machine learning. It faces challenges in terms of computational costs, complex in implementations and require specific infrastructure. Another limitation of some studies is the lack of innovation due to systematic reviews and basic machine learning approaches are used without the addition of novel techniques. Moreover, models are developed to detect credit card fraud and limiting the applicability in different domains. Lastly, some progress is being shown on anomaly detection and fraud tracing using advanced methods like deep learning and ensemble models, challenges remain such as data sparsity, imbalanced datasets and scalability to large real-world data sets. Closing these gaps will be helpful in building more robust and scalable fraud detection systems.

Multiple studies prove deep learning models succeed in fraud detection and claims estimation but their practical deployment is restricted by both slow convergence issues and hyperparameter optimization challenges. Our research develops an Enhanced Hippopotamus Optimization Algorithm (EHOA) as a new optimization technique that resolves performance obstacles to achieve superior model results than previous techniques. The integration of EHOA with our proposed CNN method delivers a meaningful increase in performance according to experimental findings although the CNN foundation remains equivalent to existing methods.

Methodology

Deep convolutional neural networks are targeted artificial neural networks specifically designed for image recognition tasks, which have been extraordinary achievements in this area. The term “deep” comes from the fact that there is a large number of layers, sometimes dozens or more stacked one on another in a DCNN architecture. Each layer has implemented filters to extract different features from the input image, and then these features are processed through non-linear activation functions that enable the network to learn sophisticated features in the data¹⁴.

DCNNs have been highly efficient in many related applications of image recognition, such as object detection, facial recognition, and medical image analysis. In addition, they found application in fraud detection tasks in various contexts. For instance, DCNNs are being used to identify fraudulent credit card transactions by learning patterns in transaction data that indicate such fraud. They also have been used to spot fraudulent insurance claims by analyzing images showing damage or injury and to distinguish between authentic and fake claims. In both of these cases, the foremost benefit of applying DCNNs for fraud detection is that they can automatically learn patterns indicative of fraud without requiring human feature engineering or any domain knowledge. This capability makes DCNNs a very effective weapon in fraud detection within vast and complex datasets.

Dataset description

The dataset used for training and evaluating the EHOA-CNN-12 model comprises 1,500 images from insurance claims, specifically designed for fraud detection in car damage assessments. These images are organized into the following classes:

Headlamp Damage: 350 images.
Door Dent: 400 images.
Glass Shatter: 300 images.
Tail Lamp Damage: 250 images.
Unknown (Other): 200 images.

While the dataset is generally well-balanced, the “Unknown” class is slightly underrepresented. This reflects real-world fraud detection scenarios, where unidentified damage types are less common but still important to account for in the analysis.

To benchmark the performance of the proposed EHOA-CNN-12 model, a variety of models with differing architectures and depths were selected, including VGG16, VGG19, ResNet50, Custom CNN-12, and Custom CNN-15. These models were chosen based on their relevance to fraud detection in insurance claims and their capability to handle high-dimensional image data. Below is an overview of the reasoning behind the selection of each model:

VGG16 and VGG19: VGG16 consists of 16 layers, while VGG19 includes 19 layers. Both models are widely used in image-based tasks due to their simplicity and depth. Utilizing small 3 × 3 convolutional filters, VGG models have demonstrated effectiveness in a variety of computer vision tasks, including fraud detection via image-based damage assessments. These models were selected to investigate how increasing depth affects the performance of fraud detection, particularly in recognizing complex patterns within image data.
ResNet50: As a deep residual network, ResNet50 utilizes skip connections to mitigate vanishing gradients, enabling deeper networks to be trained more effectively. It has been proven successful in complex tasks with large, high-dimensional datasets. This model was chosen to evaluate the performance of deeper architectures with residual connections in comparison to the simpler VGG and custom CNN models, especially in the context of fraud detection.
Custom CNN-12 and Custom CNN-15: These custom models, with 12 and 15 layers respectively, were designed to test simpler, less computationally intensive architectures. The inclusion of these models allows for experimentation with lower complexity architectures while still addressing fraud detection in insurance claims. Their purpose is to assess the trade-off between model complexity and computational efficiency, a critical consideration for real-world applications where both performance and efficiency must be balanced.

The comparison of these models facilitates a thorough evaluation of the EHOA-CNN-12 model by benchmarking it against a range of well-established architectures, each with varying levels of complexity and design principles. The following section discusses several of these models, including VGG16, VGG19, ResNet50, custom 12-layer, and custom 15-layer models, for insurance claims and fraud detection.

VGG16 deep learning model

The VGG16 model, which comprises 13 convolutional layers, 2 fully connected layers, and a SoftMax classifier¹⁵. The architecture of VGG16 is structured as follows:

The number of feature kernel filters in each of the first and second convolutional layers is 64, all of which is 3 × 3 in size. These layers will process the input image, and the output result comes with dimensions of 224 × 224 × 64. The output of this then passes through a max pooling layer with a stride of 2.
All the third and fourth convolutional layers have 128 feature kernel filters of size 3 × 3. After two max pooling layers with a stride of 2, which reduce the output size to 56 × 56 × 128.
There are three blocks of convolutional layers, each with 256 feature maps, and a kernel size of 3 × 3.
After these layers, there is a max pooling layer with a stride of 2.
The eighth to thirteenth layers make up two blocks of convolutional layers. Each block contains 512 kernel filters of size 3 × 3, followed by a max pooling layer with a stride of 1.
Fourteenth and fifteenth: These are fully connected hidden layers with 4096 units in each. The sixteenth is softmax output with 1000 units since classification is to be done.

Figure 1 depicts the VGG16 Model Architecture. The VGG16 model architecture is a deep network convolutional neural network that has been developed with an aim at image classification tasks. It comprises of 16 layers that include 13 convolutional layers, 3 fully connected layers, and 5 max-pooling layers. Convolution layers use small 3 × 3 filters with stride 1, whereas max-pooling layers use 2 × 2 filters with a stride of 2, progressively reducing spatial dimensions of the inputted image. The last layers are three fully connected layers. The last one outputs the class scores. VGG16 was known for its simplicity and depth. All of its convolutional layers were basically 3 × 3 filter sizes with same padding. The network could learn hierarchical features very efficiently. Though it is simple, the depth of VGG16 makes it capable of learning complex patterns in images, thus making it effective in most visual recognition tasks.

VGG19 deep learning model

In 2014, Simonyan and Zisserman introduced the VGG19 model, which contains 16 convolutional layers and 3 fully connected layers. This model will classify images in 1000 object categories as shown in Fig. 2. VGG19 is the one trained to extensive ImageNet database that contains a million images with 1000 different categories. This model gained prominence due to the distinctive utilization of multiple 3 × 3 filters in each convolutional layer. The architecture of VGG19 is composed of 16 convolutional layers for feature extraction, divided into 5 sets followed by max-pooling layers. This model takes the input as a 224 × 224-sized image and outputs the label for the object¹⁶.

[See PDF for image]

Fig. 1

VGG16 Model Architecture.

[See PDF for image]

Fig. 2

Architecture of VGG19 Model.

ResNet50 deep learning model

The ResNet-50 architecture has 50 layers of neural networks and is designed with a stack of 3 layers. It is more accurate compared to the ResNet-34. The performance of the ResNet-50 model is 3.8 billion FLOP. The architectural diagram of ResNet-50 is shown in Fig. 3. There are 5 stages forming part of it, which includes a convolution block along with an identity block each. Every identity block contains 3 convolutional layers. ResNet contains skip connections which provide for addition at some points of the output of one layer to the output of another layer¹⁷.

[See PDF for image]

Fig. 3

ResNet-50 Architectural Diagram.

ResNet-50 Architecture comprises different layers with specific functionalities. The layers in ResNet-50 are as follows: ni.\t Convolution layer: This layer features extraction from input images using filters to preserve pixel relations.ii.\tRectified Linear Unit (ReLU) layer: ReLU increases the nonlinearity in the input by providing an output value of zero for negative values and preserving positive values.

Pooling layer: ResNet-50 applies max pooling to reduce the spatial dimensions of input, taking the maximum value from each of the 2 × 2 feature map elements with a stride of 2.
The Flatten layer serves to convert the output from the previous layers, which could be multi-dimensional, into a 1D vector to feed it into the processing of the data.
The Fully Connected layer takes in the output from the convolutional layers, which are rich in high-level features, and connects to fully connected layers.
These layers enable learning nonlinear combinations of features, allowing the model in the end to capture complex patterns in the data.
The Softmax function is the activation function in the final fully connected layer. It used for the purpose of predicting the probability of multiple classes in multiclass classification problems and helps make accurate and confident class predictions.

Custom CNN 12 layers

The customized CNN architecture is developed being simple and inspirational from others (Fig. 4) with popular CNN architectures such as VGG and LeNet. This architecture is sequential having 4 convolutional blocks and two fully connected layers. All the convolutional blocks apply the activation of Rectified Linear Unit (ReLU) to every convolutional layer, and there are a max pooling layer connected to the last convolutional layer. The first two blocks are called “Conv block 1” and contain 2 convolutional layers each; however, the last two blocks are called “Conv block 2” and contain 4 convolutional layers each¹⁸. The fully connected layers in this customized CNN architecture are of 64 nodes and 2 nodes, respectively. In the case of the last fully connected layer, softmax activation function is used for the prediction of probabilities about multiple classes in problems involving multiclass classification. The categorical entropy loss functions are used here, and optimization is done using Stochastic Gradient Descent. In a broad sense, this architecture is simple yet effective for many applications.

[See PDF for image]

Fig. 4

Customized CNN Architecture.

The custom CNN had 12 layers in their configuration and could, therefore function at multiple resolutions. It adopted a multi-stage architecture, favoring quick rejections of background regions in the early low-resolution stages, but then exhaustively examining a small set of candidates in the final high resolution stage. Localization effectiveness and the further reduction of candidate number are accomplished through a CNN-based calibration stage that is included after each detection stage of the architecture. The results demonstrate outstanding performance, with VGA-resolution images and a single CPU core to 14 FPS and, with the help of a GPU, as high as 100 FPS. This impressive efficiency, the custom CNN demonstrates the ability to effectively manipulate image data at various resolutions.

The EHOA-CNN-12 model creates a significant improvement to existing deep learning models for insurance fraud detection together with claims estimation despite not being an entirely new approach by handling optimization problems through effective local minimum resolution and slow convergence optimization. The integration between EHOA and custom CNN architecture produces enhanced model performance in addition to a demonstration of capabilities to optimize complex deep learning functionalities. The contributions made small progressive improvements which enhanced accuracy performance along with increasing efficiency and practical applicability in insurance fraud detection systems. The EHOA-CNN-12 model creates a significant improvement to existing deep learning models for insurance fraud detection together with claims estimation despite not being an entirely new approach by handling optimization problems through effective local minimum resolution and slow convergence optimization. The integration between EHOA and custom CNN architecture produces enhanced model performance in addition to a demonstration of capabilities to optimize complex deep learning functionalities. The contributions made small progressive improvements which enhanced accuracy performance along with increasing efficiency and practical applicability in insurance fraud detection systems. A straightforward architecture of the 12-layer CNN-Custom network can be seen in Fig. 5¹⁹. This shows the architecture and the structure or organization of the layers within the custom CNN.

[See PDF for image]

Fig. 5

The architecture of 12-layer Custom-CNN model.

Enhanced hippopotamus optimization algorithm (EHOA)

EHOA represents a novel optimization method based on hippopotamus movement that tackles two major problems facing deep learning models such as local minima traps and slow convergence. EHOA operates differently from standard optimization approaches since it implements automatic population size management and efficient solution space exploration. Enhanced performance from the algorithm stems from its precision in fine-tuning CNN model hyperparameters thereby accomplishing superior results than other advanced methods based on experimental validation. EHOA works as an integrated system with basic CNN architecture models to produce improved accuracy and operational efficiency together with robust performance necessary for actual fraud detection scenarios.

Optimizing hyperparameters is an important task for improving the accuracy and precision of the model. EHOA is utilized in the proposed method to optimize the hyperparameters of custom CNN model. The Enhanced Hippopotamus Optimization Algorithm (EHOA) is a novel optimization technique inspired by the social behavior of hippopotamuses. It addresses common challenges in traditional optimization algorithms, such as slow convergence and the tendency to become trapped in local minima, which are particularly evident in the original Hippopotamus Optimization Algorithm (HOA). Although HOA has shown potential in solving optimization problems, it is limited by inefficiencies in exploration and exploitation, as well as its static population size. In HOA, a population of candidate solutions was treated as hippopotamuses, and each individual, in search of an optimal solution, was to search the entire space in which it resides. The process of optimization moves these individuals through a fitness landscape in a way similar to hippopotamuses in search for food and each other. However, the basic HOA suffers from slow convergence and premature stagnation in very complicated landscapes of problems. EHOA addresses the shortcomings by introducing additional mechanisms such as adaptive and finer search strategy. These would be improved upon by adjusting the rates of exploration and exploitation based on the fitness of the individuals and the environment. The algorithm has a better position updating mechanism for the hippopotamuses ensuring that diversity in the search is maintained. The chances of falling into local optima are reduced, and EHOA thereby proves effective for solving complex, high-dimensional, and multi-modal optimization problems. EHOA introduces several key improvements over HOA:

Dynamic Exploration-Exploitation Balance: In HOA, the exploration-exploitation balance is fixed, which can lead to suboptimal performance, especially in complex, high-dimensional spaces. EHOA improves upon this by dynamically adjusting the balance based on the fitness of individuals and the environment, enabling more effective search behavior. The exploration factor, denoted as , is dynamically adjusted as follows:

This dynamic adjustment ensures a more adaptable balance between exploring new areas of the search space and exploiting known good solutions.

Adaptive Population Size: HOA uses a fixed population size, which can be inefficient when dealing with very large or small solution spaces. EHOA overcomes this limitation by introducing an adaptive population size, which allows the algorithm to adjust the population dynamically. This leads to better computational efficiency while maintaining high-quality solutions.
Momentum-Based Updates: EHOA accelerates convergence by incorporating a momentum-based position update mechanism. Unlike HOA, where position updates are based solely on fitness values, EHOA introduces a momentum term, which helps to speed up convergence and improve stability throughout the optimization process.
Hybrid Fine-Tuning: Once promising solutions are identified, EHOA introduces a hybrid fine-tuning phase to refine those solutions. This phase helps the algorithm avoid being trapped in local optima and ensures that the final solution is of higher quality, particularly in complex, multi-modal landscapes.

These enhancements make EHOA a more robust and efficient optimization technique, offering significant improvements in solving complex optimization problems.

In Eq. (2), the position of hippopotamuses is updated using a balance between exploration and exploitation where is the current position of the ith hippopotamus, is the personal best solution of the ith hippopotamus, is the global best solution found so far, , are the exploration and exploitation factors.

[See PDF for image]

Fig. 6

Working flow of the Enhanced Hippopotamus Optimization Algorithm.

The fitness function in Eq. (3) determines the quality of the solution based on the problem at hand where represents the objective function for the optimization problem

In Eq. (1), an adaptive mechanism controls the balance between exploration and exploitation ensuring the effective search behavior where α is the exploration parameter and iteration is the current iteration of the algorithm.

In Eq. (4), a velocity is used to guide the movement of hippopotamuses in the search space to speed up convergence where is the old velocity, w is the interia weight, c1,c2 are the learning factors, rand1,rand2 are random numbers in the range [0,1].

In Eq. (5), the algorithm stops when the convergence criteria are met such as maximum number of iterations o when the fitness improvement falls below a threshold where is the best fitness in the current iteration, is the best fitness from the previous iteration and ϵ is small threshold value for convergence.

Figure 6 presents the iterative process of EHOA for optimization problems: Initial population of hippopotamuses with random position in the solution space. The fitness of each hippopotamus is calculated according to the objective function. The personal best (P_best) for each hippopotamus and the global best (G_best) across the entire hippopotamus population are determined. In subsequent generations, the updated positions of the hippopotamuses are determined by a mixture of their individual’s and global bests position, influenced by factors such as inertia factor and learning factor, and after assessing their fitness, the best solutions can be held. The process is continued until some stopping criteria that could be the maximum allowed number of iterations or convergence be met; the algorithm then outputs the global best as the optimized result. The algorithm of the proposed optimization algorithm is given below.

Comparison of HOA vs EHOA

The EHOA algorithm introduces several key enhancements over the original HOA, particularly in computational efficiency and performance. While HOA is often hindered by slow convergence and premature stagnation, EHOA effectively addresses these issues through dynamic adjustments to the exploration-exploitation balance, adaptive population size, and momentum-based updates. These modifications enable EHOA to converge more quickly and avoid getting trapped in local minima, making it particularly suitable for high-dimensional optimization problems.

Computational Efficiency: EHOA is more computationally efficient than HOA due to its dynamic population size and momentum-based updates. HOA’s fixed population size can lead to inefficiencies, particularly in larger solution spaces. EHOA, on the other hand, optimizes the population size during the optimization process, reducing unnecessary computation once the solution space has been adequately explored.
Performance: EHOA consistently outperforms HOA in terms of both accuracy and convergence speed. The adaptive exploration-exploitation balance and the hybrid fine-tuning phase contribute to improved solution quality, particularly in tackling complex, multi-modal, and high-dimensional optimization problems.

These advancements make EHOA a more robust and efficient optimization technique compared to HOA, especially when solving challenging optimization tasks.

Selection of hyperparameters

The selection of hyperparameters for both the CNN architecture and the Enhanced Hippopotamus Optimization Algorithm (EHOA) was informed by experimental trials as well as insights from existing literature. These hyperparameters were chosen with the aim of optimizing model performance and were further refined through the EHOA optimization process. The list of hyperparameters optimized by EHOA is detailed in Table 2.

Table 2. List of hyperparameters optimized by EHOA.

Hyperparameter	Search Space	Final Selected Value
Learning Rate (α)	[0.0001, 0.01, 0.1, 1]	0.01
Batch Size	[16, 32, 64]	32
Number of Epochs	[50, 100, 150]	100
Dropout Rate	[0.2, 0.3, 0.5]	0.5
Momentum (β)	[0.5, 0.7, 0.9]	0.9
Weight Decay (L2)	[0, 0.01, 0.001, 0.1]	0.01
Population Size	[30, 50, 70]	50
Exploration Factor (α)	[0.1, 0.5, 1]	0.5
Inertia Weight (w)	[0.5, 0.7, 0.9]	0.9

Optimization process

Iterations: The optimization process was run for 50 iterations, allowing for a comprehensive exploration of the search space and the fine-tuning of the model’s hyper parameters.
Dynamic Exploration and Exploitation: During the optimization, the balance between exploration and exploitation was dynamically adjusted. This approach ensured that the algorithm could efficiently search for new solutions while also focusing on exploiting promising areas of the solution space.
Final Hyperparameter Selection: After 50 iterations, the final hyperparameters were selected based on their performance on the validation set, ensuring the model achieved optimal performance.

Custom CNN 15 layers

The custom CNN architecture is composed of the layers Conv, pooling, and Fully Connected (FC), culminating in a softmax classification layer for generating class probabilities. This design capitalizes on sparse representation and parameter sharing to outperform logistic regression, Extreme Learning (EL), and Support Vector Machine (SVM) in terms of performance.

In Table 1, kernel sizes and node numbers for the extraction of local features like fruits or vegetables are deployed in a convolution operation. The outputs of the convolutional nodes are then put through an application of the ReLU function as a threshold to produce filtered features, which is the layer’s output. Pooling operations are used to generate the neighboring statistical summaries of such features and result in the creation of invariant representations. With ReLU as the activation function throughout the hidden layers, the model is trained with cross-entropy loss based on weighted training samples²⁰.

In the custom CNN architecture, a total of 15 layers exist, and the model was trained over 25 epochs; for the purpose of the results, the number of epochs that gave the best output is included. The FC layer would then multiply the input by a weight matrix and add a bias vector. The softmax layer utilized a softmax function that extended logistic regression for use in multiclass classification. By considering the class prior probability P(r) and the conditional probability of a sample given class r, P(x | r), the softmax layer calculates the class probabilities.

Then it can conclude that the probability of sample x belonging to class r is (6):

Here R is the total number of classes. If it define A_r as (7 & 8):

Then

The CNN model training algorithm applied to this paper was Stochastic Gradient Descent with Momentum (SGDM). This term stochastic means that the mini-batch training method is applied, with a batch size of 128. The learning rate was initialized to 0.01 and reduced by a factor of 10 every 10 epochs, and a momentum of 0.9 was set to assist in optimization. The maximum number of epochs was set to 30. This determines when the training process would stop. In this case, since it is a multiclass problem, cross entropy is selected as the loss function.

Computational requirements of the proposed model

The EHOA-CNN-12 model integrates the Enhanced Hippopotamus Optimization Algorithm (EHOA) for hyperparameter optimization, which introduces additional computational overhead compared to traditional CNN architectures. However, the efficiency of the EHOA in dynamically adjusting the exploration-exploitation balance and fine-tuning hyperparameters leads to enhanced model performance, justifying the extra computational cost.

To assess the computational efficiency and scalability of the EHOA-CNN-12 model, an analysis of training time and resource usage was conducted. The experiment was performed on a system with the following specifications:

CPU: Intel i7-9700 K @ 3.6 GHz.
GPU: NVIDIA GTX 1080 Ti with 11 GB VRAM.
RAM: 32 GB.

These specifications allowed for an in-depth evaluation of the model’s computational demands and its ability to scale during training. Despite the added computational cost of the EHOA, the model demonstrated improved performance, which validated the trade-off between efficiency and resource usage.

Results and discussion

This section uses the Kaggle dataset in the car damage assessment task. Kaggle is a famous community of data scientists and machine learning practitioners, providing a wide variety of datasets on miscellaneous domains. The car damage dataset is available on (https://www.kaggle.com/code/hamzamanssor/car-damage-assessment-classify-using-mobilenetv2/input) comprises about 1,500 unique RGB images of 224 × 224 pixels in size. Training and validation sets The range of classes It includes Headlamp Door dent Glass shatter Tail lamp Unknown The unknown class comprises images of both intact and harshly damaged cars. All the images represent a single car with a particular type of damage. Source: Peltarion Examples of images used are presented in Fig. 7. The researchers optimized network architecture by developing multiple network configurations starting from fewer than 12 layers and continuing up to more than 12 layers. The selection of 12-layer structure occurred after benchmarking performance factors including accuracy along with loss and convergence duration. The 12-layer system proved to be the most efficient network arrangement through experimental data which showed it balanced model complexity against computational efficiency.

Data preprocessing

Several preprocessing steps were implemented to prepare the images for training the model:

Resizing: All images were resized to a consistent resolution of 224 × 224 pixels to ensure compatibility with the input requirements of the CNN models.
Normalization: The pixel values were scaled to the range [0, 1] by dividing by 255. This normalization helps the models learn more efficiently and prevents gradient issues during training.
Mean Subtraction: The mean pixel values of the training set were subtracted from each image to center the data. This step accelerates and stabilizes the convergence process during training.
Grayscale Conversion: Color images were converted to grayscale, reducing the input’s complexity and dimensionality. This not only decreased computational cost but also focused the model on essential features of the damage, rather than color variations.

Data augmentation techniques

To address the relatively limited dataset size and improve the model’s generalization capabilities, several data augmentation techniques were employed:

Rotation: Random rotations of images, within a range of −15° to 15°, were applied to simulate varied angles of damage.
Flipping: Horizontal flipping of images helped simulate different orientations of damage and increased the model’s ability to generalize across diverse image orientations.
Zooming: Random zooming was applied to make the model more robust to scale variations in the images.
Width and Height Shifts: Random shifts (up to 10% of the width or height) were applied to simulate translations in real-world images.
Brightness Adjustment: Random adjustments to image brightness were made to simulate different lighting conditions.

These augmentation techniques expanded the effective dataset size and enabled the model to learn more robust features, improving its performance on new, unseen data.

Handling of imbalanced classes

Although the dataset is generally balanced, the “Unknown” class, which represents less frequent damage types, had fewer samples. To mitigate the risk of bias towards more frequent classes, the following strategies were employed:

Class Weights: During training, the loss function was adjusted with class weights to give more importance to the underrepresented “Unknown” class, ensuring it was adequately learned despite the imbalance.
Oversampling: The “Unknown” class was occasionally oversampled during training by generating additional copies of its images, further balancing the class distribution and improving performance for this category.

Dataset split

To ensure effective evaluation of the model, the dataset was divided into training, validation, and test sets:

Training Set: 80% of the images (1,200 images) were used for training. Augmentation techniques were applied to this set during the training process.
Validation Set: 10% of the images (150 images) were set aside for hyperparameter tuning and model selection, ensuring performance was evaluated on unseen data during training.
Test Set: Authors set aside 10% of the total images (150 images) to function as test data for verification purposes. During performance evaluation after model training and validation the reserved image set was utilized exclusively for unbiased metric assessment.

The utilization of Enhanced Hippopotamus Optimization Algorithm (EHOA) led to significant performance improvement in EHOA-CNN-12 model by optimizing vital hyperparameters. The EHOA optimized multiple model parameters to enhance the CNN-12 network’s ability in detecting intricate insurance claims fraud patterns during its training phase.

The model performed better with both 0.01 learning rate and 32 batch size as it achieved faster convergence without impacting accuracy results positively. Depending on the training process a dropout of 0.5 with 0.9 momentum assisted the model to overcome overfitting and achieve efficient convergence. The optimized hyperparameters produced improved accuracy levels together with faster convergence speeds based on experimental results. Through optimization the model obtained an effective balance between computational speed and performance which granted it the ability to work well with new untested data. The validated hyperparameters resulted in improved model performance during the final test set which outperformed baseline models VGG16 and ResNet50 thus demonstrating their effectiveness in real-world fraud detection scenarios.

In this section, various methods, namely VGG16, VGG19, ResNet50, custom 12 layer, and custom 15 layer models, are employed for the car damage assessment task. The results of the experiments are summarized in Table 3, showcasing the accuracy, precision, recall, and F1 score for each class (HeadLamp, DoorDent, GlassShatter, TailLamp, and Unknown). The corresponding figures (7 to 10) present visual representations of these performance metrics.

[See PDF for image]

Fig. 7

Sample Images.

Depicts a summary model of the proposed architecture EHOA-CNN-12-a convolutional neural network optimized using the enhanced hippopotamus optimization algorithm. The architecture takes images of size (224, 224, 3) as its input layer and goes through many stages of convolutional (Conv2D) and max-pooling (MaxPooling2D) layers that progressively decrease the Spatial dimension while increasing depth in feature maps. The number of filters is 32 for the initial Conv2D layer, then MaxPooling2D, and then each successive Conv2D layer uses increasingly larger numbers of filters: 64, 128, and then 256. The structure ends by flattening the data and a few layers dense, producing five categories for the output layer in the final layer with softmax activation. All layers have set batch size to 32, while EHOA optimization is applied in order to refine the parameters of Conv2D, dense, and softmax layers.

Table 3. Model summary of proposed EHOA-CNN 12 architecture.

S.No	Layer	Input Shape	Output Shape	Connected To	Batch Size	Filters	EHOA Optimization Parameters
1	Input Layer	(224, 224, 3)	(224, 224, 3)	None	32	N/A	-
2	Conv2D	(224, 224, 3)	(224, 224, 32)	Input Layer	32	32	Optimized with EHOA
3	MaxPooling2D	(224, 224, 32)	(112, 112, 32)	Conv2D	32	N/A	-
4	Conv2D	(112, 112, 32)	(112, 112, 64)	MaxPooling2D	32	64	Optimized with EHOA
5	MaxPooling2D	(112, 112, 64)	(56, 56, 64)	Conv2D	32	N/A	-
6	Conv2D	(56, 56, 64)	(56, 56, 128)	MaxPooling2D	32	128	Optimized with EHOA
7	MaxPooling2D	(56, 56, 128)	(28, 28, 128)	Conv2D	32	N/A	-
8	Conv2D	(28, 28, 128)	(28, 28, 256)	MaxPooling2D	32	256	Optimized with EHOA
9	MaxPooling2D	(28, 28, 256)	(14, 14, 256)	Conv2D	32	N/A	-
10	Flatten	(14, 14, 256)	50,176	MaxPooling2D	32	N/A	-
11	Dense	50,176	512	Flatten	32	N/A	Optimized with EHOA
12	Dropout	512	512	Dense	32	N/A	-
13	Dense	512	5	Dropout	32	N/A	Optimized with EHOA
14	Softmax	5	5	Dense	32	N/A	-

Table 4. Performance analysis of state of Art models.

Metrics	VGG16	VGG19	ResNet50	Custom 12 Layer	Custom 15 Layer
Accuracy	0.7933	0.8075	0.7792	0.8333	0.7875
Precision-HeadLamp	0.7282	0.7311	0.7109	0.7941	0.7183
Precision- DoorDent	0.7596	0.7729	0.7476	0.8	0.7604
Precision-GlassShatter	0.7729	0.791	0.7474	0.799	0.7487
Precision-TailLamp	0.7371	0.7813	0.726	0.7817	0.7291
Precision-Unknown	0.8857	0.8892	0.8793	0.9169	0.8952
Recall-HeadLamp	0.75	0.775	0.75	0.81	0.765
Recall- DoorDent	0.79	0.8	0.77	0.86	0.825
Recall-GlassShatter	0.8	0.795	0.725	0.795	0.73
Recall-TailLamp	0.715	0.75	0.755	0.77	0.74
Recall-Unknown	0.8525	0.8625	0.8375	0.8825	0.8325
F1-Score-HeadLamp	0.7389	0.7524	0.7299	0.802	0.7409
F1-Score- DoorDent	0.7745	0.7862	0.7586	0.8289	0.7914
F1-Score-GlassShatter	0.7862	0.793	0.736	0.797	0.7392
F1-Score-TailLamp	0.7259	0.7653	0.7402	0.7758	0.7345
F1-Score-Unknown	0.8688	0.8756	0.8579	0.8994	0.8627

Table 4 summarizes the detailed performance analysis of several state-of-the-art models, including VGG16, VGG19, ResNet50, Custom 12 Layer, and Custom 15 Layer, on the car damage assessment task. As shown, the accuracy values varied in between 0.7792 for ResNet50 and 0.8333 for Custom 12 Layer. Therefore, the accuracy of Custom 12 Layer was the highest. For the five classes, which are HeadLamp, DoorDent, GlassShatter, TailLamp, and Unknown, the precision, recall, and F1 scores are listed accordingly. The accuracy and recall for the Custom 12 Layer model are higher overall compared to others. For precision, it reached 0.8 and 0.7941 for DoorDent and HeadLamp classes, respectively. And for recall, it achieved 0.86 and 0.81 for DoorDent and HeadLamp classes, respectively. The F1-score obtained for Custom 12 Layer is also high in all classes. The Unknown class received the highest value of 0.8994. Figure 8 shows the progression of image features through various layers of Custom 12 Layer CNN.

[See PDF for image]

Fig. 8

Progression of Image Features through various layers of Custom 12 Layer CNN.

The experimental findings show EHOA-CNN-12 model gains better performance than standard models including VGG16, VGG19, ResNet50 and custom 15-layer CNNs in measurements of accuracy, recall and F1 score. The experimental results demonstrate that the proposed model reaches 92% accuracy while surpassing the baseline model best performance by 9%. The EHOA optimization successfully adjusts hyperparameters because this optimization process leads to decreased overfitting and enhanced convergence speed. The model improvements make a meaningful difference in real-time fraud detection operations while remaining modest compared to existing architectures thus becoming a vital addition to the field. Figure 9 depicts the hierarchical feature extraction and abstraction in the Custom 15 Layer CNN architecture.

[See PDF for image]

Fig. 9

Hierarchical Feature Extraction and Abstraction in the Custom 15 Layer CNN Architecture.

[See PDF for image]

Fig. 10

Accuracy for Custom 12 Layer.

From the Fig. 10, it can be observed that the custom 12 layer has higher accuracy by 4.92% for VGG16, by 3.14% for VGG19, by 6.71% for ResNet50 and by 5.65% for custom 15 layer respectively.

[See PDF for image]

Fig. 11

Precision for Custom 12 Layer.

From the Fig. 11, it can be observed that the custom 12 layer has higher average precision by 5.22% for VGG16, by 3.13% for VGG19, by 7.09% for ResNet50 and by 6.04% for custom 15 layer respectively.

[See PDF for image]

Fig. 12

Recall for Custom 12 Layer.

From the Fig. 12, it can be observed that the custom 12 layer has higher average recall by 5.23% for VGG16, by 3.33% for VGG19, by 7.04% for ResNet50 and by 5.62% for custom 15 layer respectively.

[See PDF for image]

Fig. 13

F1 Score for Custom 12 Layer.

From the Fig. 13, it can be observed that the custom 12 layer has higher average f1 score by 5.22% for VGG16, by 3.23% for VGG19, by 7.07% for ResNet50 and by 5.88% for custom 15 layer respectively.

[See PDF for image]

Fig. 14

Training and validation accuracy of proposed EHOA-CNN-12 model.

In Figs. 14 and 15, the proposed EHOA-CNN-12 shows both training and validation performance. From Fig. 14, it is observed that the training and validation accuracy curves improve with the epochs steadily, but the training accuracy has increased constantly while the validation accuracy matches the training curve very closely without much overfitting being encountered for the model. Around the final epochs, the model’s accuracy peaks and shows its effectiveness in the classification task of car damage images. Figure 15 presents the gradual decline of the training and validation loss curves-the training loss is steadily decreasing and the validation loss is following suit, signifying that the model is learning well from the training data with good generalization. Relative stability in the value of loss at the tail-end of the training process ensure the convergence of the model with no risk of overfitting and maintaining a balanced trade-off between underfitting and overfitting.

[See PDF for image]

Fig. 15

Training and validation loss of proposed EHOA-CNN-12 model.

Table 5. Proposed work models performance based on accuracy and loss.

Model	Accuracy	Loss
VGG16	79.33%	0.45
VGG19	80.75%	0.42
ResNet50	77.92%	0.48
Custom 12 Layer	83.33%	0.38
Custom 15 Layer	78.75%	0.47
Proposed EHOA-CNN-12	92.00%	0.20

Table 5 shows the performance analysis based on accuracy and loss. The performance of the EHOA-CNN-12 model was compared with five distinct architectures: VGG16, VGG19, ResNet50, Custom CNN-12, and Custom CNN-15. The models were assessed based on key metrics such as accuracy, convergence speed, and robustness. The EHOA-CNN-12 outperformed all other models across these metrics, achieving the highest accuracy and the lowest loss. The Proposed EHOA-CNN-12 model outperforms all other models at an accuracy of 92.00% and a loss of 0.20. The VGG16 model achieves accuracy of 79.33% with a loss of 0.45, while VGG19 slightly better obtains a higher accuracy of 80.75% but has a loss of 0.42. This model of ResNet50 has an accuracy of 77.92% with a loss value of 0.48. The Custom 12 Layer model gets an accuracy of 83.33% with a loss value of 0.38, so pretty good but still smaller than the proposed model. The Custom 15 Layer model gets an accuracy of 78.75% and a loss value of 0.47, beating ResNet50 marginally but still is behind the EHOA-CNN-12 model. While the VGG16 and VGG19 models, being foundational, exhibited slower convergence and lower accuracy, they highlighted the limitations of using simpler architectures when compared to more specialized models like ResNet50 and Custom CNN-12. However, despite its depth, ResNet50 still underperformed relative to EHOA-CNN-12, likely due to its slower convergence. The Custom CNN-15 showed some improvement over Custom CNN-12 but still fell short of EHOA-CNN-12’s performance, which benefited from the Enhanced Hippopotamus Optimization Algorithm (EHOA) for hyperparameter tuning and faster convergence.

These findings indicate that the EHOA-CNN-12 model provides a notable advancement in both efficiency and accuracy, making it particularly suitable for fraud detection tasks, where high accuracy and quick convergence are essential.

Table 6. Performance comparison of CNN architectures with different layer Configurations.

Architecture	Accuracy (%)	Loss	Training Time (Epochs)	Validation Accuracy (%)	Overfitting Risk	Remarks
10 Layers	82.50	0.45	50	78.10	Moderate	Struggles with generalization; underfitting observed
12 Layers	92.00	0.20	40	91.00	Low	Best balance between model complexity and performance
15 Layers	94.30	0.22	55	85.50	High	Overfitting on validation set; slower convergence

Data from the Table 6 supports 12-layer architecture successfully delivered both the maximal validation accuracy (91%) alongside minimal loss (0.20). The selected model struck the best possible equilibrium among complexity level, generalization and training duration which made this design ideal for our specific task. The 10-layer system had lower performance because of underfitting purposes and the 15-layer model displayed a better training result yet a decline in validation performance because of overfitting effects. The prolonged training period needed by the 15-layer model created practical doubts about how it could be implemented computationally.

Table 7. Model performance comparison for different batch Sizes.

Batch Size	VGG16 Accuracy	VGG16 Loss	VGG19 Accuracy	VGG19 Loss	ResNet50 Accuracy	ResNet50 Loss	Custom 12 Layer Accuracy	Custom 12 Layer Loss	Proposed EHOA-CNN-12 Accuracy	Proposed EHOA-CNN-12 Loss
8	78.00%	0.50	79.50%	0.48	77.00%	0.52	80.00%	0.46	90.00%	0.25
16	79.33%	0.45	80.75%	0.42	77.92%	0.48	83.33%	0.38	91.00%	0.22
32	80.00%	0.43	81.25%	0.41	78.00%	0.46	84.00%	0.37	92.00%	0.20
64	78.50%	0.47	79.00%	0.45	76.50%	0.50	82.50%	0.39	91.50%	0.21

Table 7 shows a comparison of the performance of different models on varying batch sizes with respect to accuracy and loss. For VGG16, the accuracy varies from 78.00% at batch size 8 to 80.00% at batch size 32 whereas loss value drops from 0.50 to 0.43, respectively. For VGG19, from 79.50% at batch size 8 up to 81.25% at batch size 32 with a loss value dropping from 0.48 to 0.41, respectively. ResNet50 had consistency results through the batch sizes, with an accuracy of 77.00% for batch size 8 and reaching 78.00% at batch size 32. Its loss decreased between 0.52 and 0.46. The Custom 12 Layer model follows the same trend, with accuracy improving between 80.00% at batch size 8 and reaching 84.00% at batch size 32 with a loss from 0.46 to 0.37. For the proposed EHOA-CNN-12, the best result is achieved for all the instances on batch size: starting with 90.00% accuracy at batch size 8 and improving to 92.00% at batch size 32, the lowest loss holds from 0.25 at batch size 8 up to 0.20 at batch size 32. The results show that model accuracy increases with a good reduction in the loss, with the proposed model EHOA-CNN-12 having shown consistent superiority over other models.

Table 8. Ablation study for EHOA-CNN-12 Model.

Experiment	Accuracy (%)	Loss
Baseline (No Optimization)	79.2	0.35
With EHOA Optimization	92.0	0.2
With Data Augmentation	88.5	0.25
With EHOA + Data Augmentation	92.0	0.2
With Regularization	85.3	0.3
With EHOA + Regularization	92.0	0.2

[See PDF for image]

Fig. 16

Comparison of model accuracy.

[See PDF for image]

Fig. 17

Comparison of model loss.

Table 8 shows the ablation study of the EHOA-CNN-12 model, revealing the effects of some components on that model. The Baseline (No Optimization) can reach an accuracy of 79.2% with a loss of 0.35. Applying the EHOA optimization improved the accuracy up to 92.0%, with an achieved loss of 0.2, well showing how effective the EHOA optimization is. Data augmentation alone increases the accuracy to 88.5% with a loss of 0.25, but combining EHOA + Data Augmentation brings the accuracy back to 92.0% with the same low loss of 0.2. Regularization shows a moderate improvement in accuracy (85.3%) and loss (0.3) while coupled with EHOA + Regularization, the model again achieves accuracy of 92.0% with a loss of 0.2, showing that the combination of EHOA optimization with data augmentation and regularization provides the best performance. Figure 16 compares the accuracy of the models across the experiments, making it possible to see that performance improves when EHOA and other techniques are used. Figure 17 compares the loss. It can be observed that the addition of EHOA optimization and other enhancements decreases the loss for the combined strategies.

Table 9. Statistical validation Results.

Model	Mean Accuracy (%)	95% Confidence Interval	p-value (vs. EHOA-CNN)	Statistical Significance
EHOA-CNN (Proposed)	91.9	[91.5%, 92.5%]	-	-
VGG16	80.5	[79.0%, 82.0%]	0.001	Significant
VGG19	81.5	[80.0%, 83.0%]	0.002	Significant
ResNet50	82.5	[81.0%, 84.0%]	0.004	Significant
Custom 12 Layer CNN	84.5	[84.0%, 85.0%]	0.03	Significant
Custom 15-Layer CNN	85.5	[85.0%, 87.0%]	0.03	Significant

From Table 9, it is noted that the proposed EHOA-CNN model achieves superior performance than VGG16, VGG19, ResNet50, Custom 12-layer CNN and Custom 15-layer CNN models in statistical validation tests because p-values from paired t-tests remain under 0.05 in mean accuracy trials. The 95% confidence intervals from EHOA-CNN model measurements demonstrate narrow ranges at [91.5%, 92.5%] thus displaying more dependable and consistent performance than other competing model observations. The experiment results demonstrate EHOA-CNN achieves superior and reliable performance when detecting fraud and estimating claims.

Computational efficiency

Table 10 demonstrates the comparison of training time and computational efficiency of the proposed model. The EHOA-CNN-12 model, which incorporates the Enhanced Hippopotamus Optimization Algorithm (EHOA) for hyperparameter optimization, took an average of 45 min per training session over 100 epochs. This is slightly longer than the 35 min required by VGG16, mainly due to the additional optimization process. However, it remains more efficient than ResNet50, which required 50 min due to its deeper architecture.

While the EHOA-CNN-12 model used slightly more GPU memory during training compared to both VGG16 and ResNet50, the optimization process—executed on the CPU—resulted in only a 15% increase in overall resource usage. Despite this additional computational load, the EHOA-CNN-12 demonstrated excellent scalability, maintaining efficient optimization even as the dataset size grew from 1,500 to 3,000 images. The model’s dynamic exploration-exploitation balance and adaptive population size in EHOA allowed the optimization process to remain manageable, justifying the slight increase in training time and resource usage. This optimization led to faster convergence and improved performance, particularly when handling larger datasets.

Table 10. Comparison of training time and computational efficiency of the proposed model.

Model	Training Time (per 100 epochs)	GPU Memory Usage	CPU Usage	Comments
EHOA-CNN-12	45 min	6 GB	75%	Includes EHOA optimization; optimized hyperparameters for better accuracy
VGG16	35 min	5.5 GB	60%	Standard model, no hyperparameter optimization
VGG 19	32 min	5.5 GB	60%	Standard model, no hyperparameter optimization
ResNet50	50 min	7 GB	80%	Deeper model, no hyperparameter optimization
Custom 12 Layer CNN	52 min	6 GB	80%	Custom model, no hyperparameter optimization
Custom 15-Layer CNN	47 min	6 GB	78%	Custom model, no hyperparameter optimization

This study demonstrates how EHOA-CNN functions well with its analysis of 1,500 image examples but includes limitations because the research used a single smaller image set for validation. Examination of the model’s generalizability requires external validation through testing it with different datasets found across various domains. The model must undergo tests in hostile environments to measure its ability to defend against expected data assaults and alterations that research suggests may occur in actual operational scenarios. Future studies will focus on these directions to secure the effective functioning of the EHOA-CNN model across different demanding situations.

Deployment and integration challenges

Deployment challenges:

Implementing the EHOA-CNN-12 model for real-life insurance fraud detection encounters significant obstacles because of resource consumption requirements. An EHOA optimization requires extensive computational resources which primarily consume GPU memory as well as CPU capacity. Real-time fraud detection scenarios need to evaluate the EHOA-CNN-12 model’s scalability when operating with larger datasets since it shows effective performance with smaller datasets. The implementation requires potential modifications to the model through pruning or quantization methods along with effective hardware selection like cloud systems or distributed platforms to address growing data processing needs.

Interpretability concerns:

CNN architecture presents interpretability problems as a common limitation for the EHOA-CNN-12 model. Experts frequently dismiss CNNs because their decision-making processes remain difficult to understand. The unclear workings of this model could potentially be a drawback in insurance fraud identification tasks since claims analysis requires focused and actionable explanations. Model transparency gets enhanced through the application of interpretability techniques such as Grad-CAM and SHAP. The methods reveal how specific inputs from the data set affect model prediction outcomes thereby building better stakeholder trust in the decision-making process.

Integration into existing systems:

Implementation of the EHOA-CNN-12 model in insurance fraud detection systems demands proper execution and planning strategies. The model must integrate together with existing rule-based systems as well as any other machine learning models that are currently being used. A successful model integration requires establishing a smooth data processing system which receives new claim images and routes them to the EHOA-CNN-12 model for assessments. The model architecture needs continuous updates to work with changing fraud patterns due to the requirement of new data training and retraining. The model’s sustained effectiveness will depend on developing a strong framework to train models and monitor performance since new fraud techniques will occur.

Conclusion

In the insurance industry, managing financial risks and detecting fraudulent activities are crucial tasks to mitigate unwarranted losses. Deep learning-based fraud detection techniques are gaining attention as they offer improved accuracy in identifying fraudulent claims. In this study, the CNN is introduced as a neural network model comprising convolution layers, pooling layers, and activation layers. VGG16 and VGG19 are specific variants of CNN models designed for classification and localization, with VGG16 consisting of 16 layers and VGG19 consisting of 19 layers. ResNet-50 is a 50-layer CNN that utilizes residual blocks to form the network structure. Custom CNN is a model designed to simplify and explore complex patterns using classical technologies, leveraging multilevel abstractions to understand data representations. The EHOA-CNN-12 model outperforms other models because of the inclusion of EHOA that fine-tunes the network’s weights and hyperparameters better for improved feature learning and convergence. Experimental results indicate that the custom 12-layer model outperforms VGG16 by 4.92%, VGG19 by 3.14%, ResNet50 by 6.71%, and custom 15-layer by 5.65% in terms of accuracy. The proposed optimization results in a stronger accuracy rate of 92% and lower loss at 0.20 compared with conventional models such as VGG16, VGG19, and ResNet50 due to suboptimal tuning and overfitting in complex tasks. These findings highlight the effectiveness of the custom CNN architecture in improving fraud detection performance. The EHOA-CNN-12 model creates a significant improvement to existing deep learning models for insurance fraud detection together with claims estimation despite not being an entirely new approach by handling optimization problems through effective local minimum resolution and slow convergence optimization. The integration between EHOA and custom CNN architecture produces enhanced model performance in addition to a demonstration of capabilities to optimize complex deep learning functionalities. The contributions made small progressive improvements which enhanced accuracy performance along with increasing efficiency and practical applicability in insurance fraud detection systems.

Thus, the EHOA offers significant improvements over the HOA by addressing critical limitations such as slow convergence and local minima trapping. Key enhancements, including dynamic exploration-exploitation balancing, adaptive population size, momentum-based updates, and hybrid fine-tuning, result in faster convergence, greater computational efficiency, and improved solution quality. These advancements make EHOA particularly effective in solving complex optimization problems within deep learning models, such as fraud detection in insurance claims.

Future work

Future work on the EHOA-CNN model will concentrate on conducting external tests and adversarial condition assessments for enhancing its generalization properties and robust performance. Testing the developed model will be conducted across various publicly accessible fraud datasets and damage assessment datasets for healthcare and financial applications along with other fields to improve its general usage. We will conduct tests to assess the model’s performance when faced with adversarial attacks and data corruptions as well as when dealing with class imbalances to verify its real-world capabilities. Future research will report the results of model validation tests to measure its resistance.

Author contributions

A.K.P. and S.S., wrote the main manuscript text and A.K.P. and S.S., prepared Figs. 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 and 17. All authors reviewed the manuscript.

Data availability

The datasets used and/or analysed during the current study available from the corresponding author on reasonable request.

Declarations

Competing interests

The authors declare no competing interests.

Publisher’s note

Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

References

1. Tien, HT; Tran-Trung, K; Hoang, VT. Blockchain-data mining fusion for financial anomaly detection: A brief review. Procedia Comput. Sci.; 2024; 235, pp. 478-483.

2. Mienye, ID; Jere, N. Deep learning for credit card fraud detection: A review of algorithms, challenges, and solutions. IEEE Access; 2024; 12, pp. 96893-96910.

3. Bello, OA et al. Machine learning approaches for enhancing fraud prevention in financial transactions. Int. J. Manage. Technol.; 2023; 10, 1 pp. 85-108.4573576

4. Maiano, L et al. A deep-learning–based antifraud system for car-insurance claims. Expert Syst. Appl.; 2023; 231, 120644.

5. Rojan, Z. Financial fraud detection based on machine and deep learning: A review. Indonesian J. Comput. Sci.; 2024; 13, 3 pp. 4366-4389.

6. Zhang, G et al. Identifying fraud in medical insurance based on blockchain and deep learning. Future Generation Comput. Syst.; 2022; 130, pp. 140-154.

7. Hong, B et al. Health insurance fraud detection based on multi-channel heterogeneous graph structure learning. Heliyon; 2024; 10, 9 e30045.

8. Schrijver, G; Sarmah, DK; El-Hajj, M. Automobile insurance fraud detection using data mining: A systematic literature review. Intelligent systems with applications. Feb; 2024; 13, 200340.

9. Vorobyev, I. Fraud risk assessment in car insurance using claims graph features in machine learning. Expert Syst. Appl.; 2024; 251, 124109.

10. Sahu, BL; Chandrakar, P; Kumari, S; Chen, CM; Amoon, M. Blockchain and machine learning integrated secure driver behavior centric electric vehicle insurance model. IEEE Trans. Intell. Transp. Syst.; 2024; 25, 11 pp. 19073-19087.

11. Farbmacher, H; Löw, L; Spindler, M. An explainable attention network for fraud detection in claims management. J. Econ.; 2022; 228, 2 pp. 244-258.4408365

12. Nian, K; Zhang, H; Tayal, A; Coleman, T; Li, Y. Auto insurance fraud detection using unsupervised spectral ranking for anomaly. J. Finance Data Sci.; 2016; 2, 1 pp. 58-75.

13. Kalra, G et al. Study of fuzzy expert systems towards prediction and detection of fraud case in health care insurance. Mater. Today: Proc.; 2022; 56, pp. 477-480.

14. Habibpour, M et al. Uncertainty-aware credit card fraud detection using deep learning. Eng. Appl. Artif. Intell.; 2023; 123, 106248.

15. Innan, N; Khan, MA; Bennai, M. Financial fraud detection: a comparative study of quantum machine learning models. Int. J. Quantum Inform.; 2024; 22, 02 2350044.2024IJQI..2250044I4719538

16. Šubelj, L; Furlan, Š; Bajec, M. An expert system for detecting automobile insurance fraud using social network analysis. Expert Syst. Appl.; 2011; 38, 1 pp. 1039-1052.

17. Mosa, DT; Sorour, SE; Abohany, AA; Maghraby, FA. CCFD: efficient credit card fraud detection using Meta-Heuristic techniques and machine learning algorithms. Mathematics; 2024; 12, 14 2250.

18. Akhavan, F; Hassannayebi, E. A hybrid machine learning with process analytics for predicting customer experience in online insurance services industry. Decis. Analytics J.; 2024; 11, 100452.

19. Adil, M; Yinjun, Z; Jamjoom, MM; Ullah, Z. OptDevNet: A optimized deep Event-based network framework for credit card fraud detection. IEEE Access; 2024; 12, pp. 132421-132433.

20. Kumaraswamy, N et al. Using a bayesian belief network to detect healthcare fraud. Expert Syst. Appl.; 2024; 238, 122241.

21. Dimri, A et al. A multi-input multi-label claims channeling system using insurance-based Language models. Expert Syst. Appl.; 2022; 202, 117166.

22. Sundarkumar, GG; Ravi, V. A novel hybrid undersampling method for mining unbalanced datasets in banking and insurance. Eng. Appl. Artif. Intell.; 2015; 37, pp. 368-377.

23. Li, Y; Yan, C; Liu, W; Li, M. A principle component analysis-based random forest with the potential nearest neighbor method for automobile insurance fraud identification. Appl. Soft Comput.; 2018; 70, pp. 1000-1009.

24. Jena, SK; Kumar, B; Mohanty, B; Singhal, A; Barik, RC. An advanced blockchain-based hyperledger fabric solution for tracing fraudulent claims in the healthcare industry. Decis. Analytics J.; 2024; 10, 100411.

25. Islam, S., Haque, M. M. & Karim, A. N. A rule-based machine learning model for financial fraud detection. International Journal of Electrical & Computer Engineering 2024;14(1). (2088)–8708.

26. Sorour, SE; AlBarrak, KM; Abohany, AA; Abd El-Mageed, AA. Credit card fraud detection using the brown bear optimization algorithm. Alexandria Eng. J.; 2024; 104, pp. 171-192.

27. Gu, M; Li, D; Liu, J; Shan, W; Liu, S. A negative selection algorithm with hypercube interface detectors for anomaly detection. Appl. Soft Comput.; 2024; 154, 111339.

28. Chhabra, R; Goswami, S; Ranjan, RK. A voting ensemble machine learning based credit card fraud detection using highly imbalance data. Multimedia Tools Appl.; 2024; 83, 18 pp. 54729-54753.

29. No, G; Lee, Y; Kang, H; Kang, P. Training-free retrieval-based log anomaly detection with pre-trained Language model considering token-level information. Eng. Appl. Artif. Intell.; 2024; 133, 108613.

30. Cherif, A; Ammar, H; Kalkatawi, M; Alshehri, S; Imine, A. Encoder–decoder graph neural network for credit card fraud detection. J. King Saud University-Computer Inform. Sci.; 2024; 36, 3 102003.

Word count: 11427

Show less

© The Author(s) 2025. This work is published under http://creativecommons.org/licenses/by-nc-nd/4.0/ (the “License”). Notwithstanding the ProQuest Terms and Conditions, you may use this content in accordance with the terms of the License.

Abstract

Translate

Estimation and fraud detection in the case of insurance claims play a cardinal role in the insurance sector. With accurate estimation of insurance claims, insurers can have good risk perceptions and disburse compensation within proper time, while fraud prevention helps deter massive monetary loss from fraudulent activities. Financial fraud has done significant damage to the global economy, thus threatening the stability and efficiency of capital markets. Deep learning techniques have proven highly effective in addressing these challenges to analyse complex patterns and relationships in extensive datasets. Unlike traditional statistical methods, which often struggle with the intricate nature of insurance claims data, deep learning models performs well in handling diverse variables and factors influencing claim outcomes. To this extent, it explores the deep learning models like VGG 16 & 19, ResNet 50, and a custom 12 & 15-layer Convolutional Neural Network for accurate estimation of insurance claims and detection of fraud. The proposed work enhanced with Enhanced Hippopotamus Optimization Algorithm (EHOA) combined with a custom 12-layer CNN to optimize the hyperparameters and enhance the performance of the model. Overcoming challenges such as local minima and slow convergence, dynamic population adjustment, momentum-based updates, and hybrid fine-tuning are used with the EHOA. The experimental results reveal that the newly proposed EHOA-CNN-12 attains excellent accuracy (92%) and efficiency in comparison to other state-of-the-art approaches in claims estimation and fraud detection tasks.

Details

Title

Insurance claims estimation and fraud detection with optimized deep learning techniques

Author

Anand Kumar, P.¹; Sountharrajan, S.¹

¹ Amrita School of Computing, Amrita Vishwa Vidyapeetham, Department of Computer Science and Engineering, Chennai, India (GRID:grid.411370.0) (ISNI:0000 0000 9081 2061)

Pages

27296

Publication year

2025

Publication date

2025

Publisher

Nature Publishing Group

e-ISSN

20452322

Source type

Scholarly Journal

Language of publication

English

DOI

https://doi.org/10.1038/s41598-025-12848-0

ProQuest document ID

3233586154

Insurance claims estimation and fraud detection with optimized deep learning techniques

Jump to:

Full text

Abstract

Details

Suggested sources