Flexible-Clustering Based on Application Priority to Improve IoMT Efficiency and Dependability

Abstract

The Internet of Medical Things (IoMT) has overcome the privacy challenges of E-healthcare-based Internet of Things (IoT) systems to protect the joined people’s private records to IoMT infrastructures and support their information security in different layers. By deploying various medical applications, security and privacy are challenging for the IoMT via rising communications between its layers and nodes. Some case studies aimed to solve the issues and provided various methods and protocols to identify the malicious data and information, which had almost overlooked application and service priority to targeting the research and satisfying security. We addressed the dependability and privacy problems of IoMT-based applications by presenting an intelligent algorithm for node mapping and flexible clustering (NFC) via defining a graph and employing a neural network (NN). This work proposes a flexible clustering method to categorize the healthcare service providers for timely detecting faults and identifying the proper servers to join the cluster by considering service and application priority. We improve the application dependability and privacy by about 77.3–83.2% via pruning the defective nodes and employing the neighbor components to support faulty devices’ role. By removing the failed or faulty nodes, the study reduces communication delay and energy consumption, approximately 19.3–21.7% and 10.3–11.8%, respectively.

1. Introduction

Recently, medical studies addressed finding the solutions for timely detecting various diseases and providing correct healthcare services to patients. The different remote-controlling methods were presented by employing biosensors and other types. Researchers proposed E-healthcare systems to monitor people’s health records and control their vital signs, supported by IoT technology. By increasing the number of medical-based applications and combining them with other demands, IoT technology faced satisfying privacy and security problems to protect the patients’ private records and the doctor’s treatment recommendations [1,2]. The IoMT technology was customized to support medical-based applications for protecting private records and recommendations from intruders and invalid users through specialized protocols and algorithms [3,4]. By deploying IoMT, the studies demonstrated rising the joined applications to the technology’s infrastructures and creating security, availability, and dependability challenges because of growing up the complexity and communications between the different layers and nodes (Including physical, information, integration, and application layers) [5,6]. Authentication protocols aimed to identify the legitimate doctors and patients to access the shared information and data by defining the public and private keys for the joined users [7,8]. The protocols created an opportunity to protect the shared private records and recommendations for improving the security of IoMT applications. Researchers applied the cryptography techniques of symmetric and asymmetric algorithms to define different authentication keys, encryption, and decryption information to support the security of transferring data between the IoMT nodes and layers [9,10,11,12,13]. By providing trust-based services, the studies tried to solve the security and privacy problems via defining a hard limitation to provide or dedicate a server to a requester when correctness has a highlighter role than availability [14,15]. The trust-based approaches lead to the high limitations of providing a service. They can create dangerous situations in risky conditions, such as facing accidents, natural disasters, and limitations of service provider sources. Pelekoudas-Oikonomou et al. [16] focused on providing a method to utilize the blockchain approach in edge-networks of the IoMT applications to prevent sharing malicious healthcare information via the devices, which leads to improving the technology security. This work supported the security on the edge level’s nodes by protecting the shared private records and treatment recommendations. Wazid et al. [17] employed a blockchain model to improve security by protecting the data transferring of the IoMT-based E-healthcare systems via defining a key to control and access the shared information via the wireless sensors. The blockchain-based methods increase the security of the IoMT applications by employing encryption, decryption, and the authentication key, which can lead to risky conditions for specific situations with availability as the service priority. Some researchers improved the security and privacy of the IoMT infrastructures by predicting the active and passive attacks in the application layer and identifying intruders before sharing malicious data, where the precision of prediction has an impressive effect on providing proper healthcare service to the patient [18,19].

To satisfy the IoMT privacy, case studies targeted a special application to provide a method for protecting the shared information between sensor nodes and healthcare service providers. Ibaida et al. [20] addressed the privacy problem to protect the output signals of Electrocardiogram (ECG) sensors from losing information by employing a machine learning algorithm (ML) and neural network. The study can only support the privacy-preserving of the related applications to ECG signals for providing proper service to a requester. Some case studies utilized the sparse learning method for the cryptography algorithm’s decryption phase and improved the privacy of IoMT-based applications for increasing the accuracy of decrypted ECG signals, which only covered the related application to Electrocardiogram [21,22].

Some researchers focused on protecting the biosensors and other types of them to access the illegitimate doctors and vulnerabilities to avoid creating dangerous conditions by imposing malicious information on the connected sensors to the patients [23]. The studies attended to specific applications to detect cyber-attacks and intruders for preventing the different vulnerabilities by employing machine learning algorithms and Bayesian-based models to update the information [23]. The neural networks and their activation functions have an impressive effect on improving the efficiency of the IoMT applications and IoT-based E-healthcare systems by inferencing data and training them [24,25]. Nevertheless, the faint role of application and service priority creates limitations to the recent security and privacy approaches of the IoMT infrastructures.

The above-mentioned studies and concepts prove the reasons for attending the domain and providing our idea to improve the IoMT’s efficiency and dependability, which include:

• Faint role of application and service priority to define and propose security methods for IoMT-based applications
• Lack of considering application priority to provide privacy methods for the IoMT.
• Customizing the security and privacy methods to the specific applications and sensors
• Lack of targeting and generalizing methods to support the applications in facing risky situations and unpredictable conditions
• Neglecting the imposing communication delay and energy consumption overheads to the performance of the IoMT applications

We addressed the mentioned issues to provide an idea for overcoming them and improving the IoMT applications’ efficiency and dependability by analyzing availability, security, and confidence. This work pays attention to the service and application priority for presenting an intelligent four-phase algorithm to map the application nodes onto the vertices of a graph (including V vertices and E edges) and clustering them based on detecting faulty service providers. The main graph consists of the mapped application’s service provider nodes and the relationship between them and physical and information layers nodes, which are defined by the edges. The initial cluster demonstrates the initial server nodes of an application where each node identifies the neighbor cluster to utilize them in facing the defective components. To determine the proper nodes in the neighbor cluster, we use the quasi-mapping method to transfer their role onto a neural network’s neurons apart from the mapped service providers and other components of the main application [24]. NFC trains the neural network’s weights and neurons based on the service and application priority and utilizes the backward chain to impose penalties onto the NN’s weights. Due to decision making about the proper neighbor service provider and joining them to the cluster, we define a threshold value for each IoMT application by considering priority and the number of servers. After detecting faults and training the neural network, NFC prunes the weak weights and neurons identified as unfit service providers by imposing the estimated penalty on the weights. By removing the improper node and re-clustering the graph vertices and edges, we stop the defective nodes, eliminate their energy, and delay overheads for the application efficiency and improve dependability by avoiding sharing malicious data. Figure 1 indicates the steps of the case study to node mapping and flexible-clustering the graph vertices and edges, as well as quasi-mapping the neurons of a partial neural network.

By presenting an overview of the proposed idea and pointing out the recent studies’ challenges in the research domain, the main novelty and contribution of the study are as follows:

• Considering application priority to decision-making about dedicating a proper healthcare service to the requester
• Considering service priority to identify the appropriate neighbor nodes after detecting faults
• Analyzing the IoMT applications’ efficiency and dependability based on the applications and services’ priority
• Providing a method for flexible clustering a graph vertices and edges for improving security, availability, confidence, and privacy
• Providing the Equations and models to describe flexible clustering, node mapping, and estimating availability, security, privacy, and dependability
• Presenting node mapping method to transfer the application’s service providers role onto a graph vertices
• Employing a quasi-mapping approach to transfer the role of graph’s nodes onto a partial neural network’s neurons to identify the appropriate service providers nodes for joining the cluster
• Pruning the unfit and defective nodes to improve dependability and performance (total delay and energy)

To assess the efficiency of the proposed algorithm and other contributions of the study, we define four healthcare-based applications with different priorities (availability, security, privacy, etc.) for implementing them by NFC. The study analyzes the IoMT applications, which have an impressive effect on medical science, and considers the risky conditions (such as facing the accident and pandemics a disease). The four applications consist of monitoring the vital signs of the climbers and investigating biosensors to detect the cancer COVID-19, about which we present more information in Section 3. This work reports the observations and simulation results after simulating the applications’ node with the CupCarbon tool [26]. We estimate the applications’ availability, security, privacy, and dependability by injecting the faults onto the simulated nodes with random and different rates using the CupCarbon tool.

The remainder of the manuscript is as follows. We review the recent case studies in the research domain in Section 2. The data collection methods, applications, Equations, and the proposed algorithm are defined and explained in Section 3. We then report the observations and simulation results in Section 4 and conclude about the presented concepts in Section 5.

2. Related Work

According to the rising number of IoT and IoMT applications, many studies addressed the technology’s challenges and proposed approaches to tackle them and increase their efficiency. The section reviewed some research that applied different methods to support the security, trust, decision making, and other effective parameters to improve the quality of service in the IoT and Medical Things.

The security demands problems to IoMT-based infrastructure because of sharing the patients’ private records between healthcare service providers, which some case studies addressed the issue to protect the information. Khan et al. [27] proposed a specific method to timely detect the attacks and decide about service providers, which had a higher potential for decision making than the machine learning-based algorithms. The study utilized the bidirectional simple recurrent units approach to speed up training the neural networks for timely detecting the complicated attacks on the IoMT. The restriction of IoMT devices’ sources is challenging to protect privacy and security when researchers classify the different attacks and protocols to tackle the problem by considering the components’ variants [28]. According to the role of IoMT application in detecting the various diseases, the researchers endeavored to satisfy the security to safety diagnosis in the medical-based applications, which the convolutional neural network (CNN) affected to support the purposes by speed up training and increasing precision [29].

The authentication protocols and methods helped to verify legitimate doctors and patients through sharing the private records and services, as the lack of identifying legitimacy endangers the people’s health. Enamamu [30] designed a framework to authenticate the IoMT on different levels that utilized artificial intelligence to verify the output signals of the sensors as well as analyze the textual data. This work could identify the malicious and illegitimate signals and tackle them, whereas other authentication methods focused on detecting incorrect textual data. The researchers proposed different key agreements to support authentication in various levels of IoMT where the physical layer cannot utilize them because of its sensors’ resources restriction. Lee et al. [31] presented an approach to verify the authentication in the physical layer and tackle the mentioned problem without defining the private key by employing the physically unclonable function.

Moreover, some case studies applied trust-based methods to decision making and provided dependable service to ensure receiving the correct HSs by the patients. With increasing the sensitivity of the shared data and information, defining a trust-based method is challenging; Jinila et al. [32] utilized an inverse method in facing the issue by providing a zero-trust security model. Blockchain technology has a highlighted role in protecting private records and satisfying the security of big data centers by detecting attacks and intruders and providing trust-based services [33,34]. Nevertheless, the trust-based methods create some limitations for the applications with specific situations, which lack of timely service endangers the patients’ health.

Aside from providing security, authentication, and trust methods, service availability has a highlighted role in improving the IoMT’s efficiency in supporting the requirements of the connected people to the technology. Some case studies utilized the blockchain to define the availability of the different IoMT applications that provided timely access to the data sources and services by predicting and managing them [35]. Nie et al. [36] focused on satisfying the availability of IoMT’s physical layer and authenticating the private records via hash functions to profile matching. The study utilized the encryption algorithm and defined the private key to profile matching, which was allowed for users for secure-sharing of the records.

The researchers employed the IoMT infrastructure to improve the medical-based applications’ efficiency in timely detecting diseases and providing the treatment methods by remote-controlling the patients’ vital signs, such as diagnosing brain tumors and diabetes [37,38]. When the human’s neural structures had a highlighted role in inspiring from their behavior in the neural networks, neuromorphic computing and spintronic detect the body language [39,40]. The studies evidenced the significant effect of machine learning algorithms and neural networks to improve the efficiency of IoMT-based applications with various properties.

Table 1. Comparing the characteristics of the reviewed studies with the proposed idea.

Case Study	Method	Advantage	Weakness
Khan et al. [27]	- Machine learning algorithms - Recurrent units	- Timely decision-making - Detecting attacks	- Neglecting service priority - Fixed IoT nodes or applications
Rasool et al. [28]	- A contemporary review - Machine learning algorithm	- Supporting privacy in IoT - Supporting security in IoMT	- Neglecting service priority - Restrictions of the device’s resources - Fixed IoT nodes or applications
Hossen et al. [29]	- Machine learning algorithms - Diagnosing diseases	- Timely detection of skin diseases - Joining the patient to IoMT	- Neglecting service priority - Fixed on the specific application - Algorithm complexity
Enamamu et al. [30]	- Artificial intelligent - Neural networks - Authentication protocol	- Detecting the legitimacy of the doctors in IoMT - Supporting security and privacy	- Focused on security - Neglecting service priority - Fixed IoT nodes or applications
Lee et al. [31]	- Key agreement - Neural networks - Authentication protocol	- Authentication on the physical level of IoMT	- Focused on security - Neglecting service priority - Fixed IoT nodes or applications
Bevish et al. [32]	- Zero trust method - Artificial intelligence	- Supporting trust in IoMT - Supporting dependability in IoMT	- Neglecting service priority - Fixed IoT nodes or applications
Samuel et al. [33]	- Blockchain - Artificial intelligent	- Supporting security in IoMT - Supporting privacy in IoMT	- Delay in timely decisionmaking - Neglecting service priority - Fixed IoT nodes or applications
Ali et al. [34]	- Blockchain - Artificial intelligent	- Supporting security in IoMT - Supporting privacy in IoMT	- Delay in timely decisionmaking - Neglecting service priority - Fixed IoT nodes or applications
Mubashar et al. [35]	- Blockchain - Artificial intelligent	- Timely access to data sources - Predicting and managing attacks - Supporting availability in IoMT	- Neglecting service priority - Fixed IoT nodes or applications
Nie et al. [36]	- Hash function - Profile matching - Encryption algorithm	- Supporting availability in the physical layer - Authenticating the private records	- Neglecting service priority - Fixed IoT nodes or applications
Kaur et al. [37]	- Artificial intelligent - Neural networks - Diagnosing diseases	- Joining the risky patients to the IoMT infrastructure - Timely detecting brain tumor - Timely providing treatment approach	- Neglecting service priority - Fixed on the specific application - Algorithm complexity
Reddy et al. [38]	- Artificial intelligent - Neural networks - Diagnosing diseases	- Joining the risky patients to the IoMT infrastructure - Timely diabetes detection - Timely providing treatment approach	- Neglecting service priority - Fixed on the specific application - Algorithm complexity
Sharifshazileh et al. [39]	- Neuromorphic systems - Artificial intelligence - Inspiring body languages	- Managing the people and risky condition	- Neglecting service priority - Fixed IoT nodes or applications - Dependability
Alon et al. [40]	- Artificial intelligence - Inspiring body languages	- Managing the people and risky condition	- Neglecting service priority - Fixed IoT nodes or applications - Dependability
This idea	- Flexible graph clustering - Neural network - Intelligent algorithm - Modeling the node clustering	- Timely decisionmaking - Service and application priorities - Supporting dependability, availability, security, and confidence in IoMT-based applications	- Timely identifying the stations from the vehicle health service providers in IoMT-based infrastructure

presents an overview of the weaknesses and advantages of the mentioned works in comparing the proposed idea.

An overview of the related case studies to improve the IoMT’s efficiency demonstrates targeting them to satisfy its security and dependability where the role of service priority and energy efficiency is invisible. Some researchers attended to manage the power supplies and dedicate them to the devices without considering the negative impact of the failed components on imposing energy consumption and delay overheads. Further, the studies focused on providing efficient protocols and methods for the cryptography of the shared information to support the IoMT-based application security and protect the private records, in which the application priority affects the improvement or deterioration of the approaches’ efficiency. By utilizing the neural networks and clustering methods to categorize the proper service providers, the researchers can improve the prediction, detection, and decision-making methods in IoMT-based applications. This work aims to fill in the mentioned blanks of the related studies by presenting a model and algorithm to timely detect faulty service providers and cover their operations by employing the neighbor servers’ nodes. We pay attention to the application and service priority for decision making about dedicating an appropriate service to the requester and clustering them to timely fault detection. This supports the flexibility of updating the graph vertices’ initial statuses and joining new devices. The issue helps to tackle the challenges of the related energy consumption and delay to the failed or faulty nodes by pruning or stopping them. Apart from overcoming the performance problem, we improve the dependability and face the faulty nodes in risky and normal conditions based on the priorities of applications and services to increase the proposed idea’s efficiency.

3. Flexible Cluster Modeling and NFC Algorithm

The study presents the Equation, model, and a four-phase intelligent algorithm to map the application’s nodes onto graph vertices and cluster them after detecting defective service providers to identify the related neighbor servers to the application priority and join them to the cluster. To explain the proposed idea, we define four applications with different priorities (including application and service priority) and aim to support the risky conditions and recent research in medical science where collected a dataset for analyzing their efficiency. The section applies the mentioned concepts and issues of collecting datasets, describing Equations, node-mapping, and flexible-clustering algorithms.

3.1. Defining Applications and Collecting a Dataset

The subsection addresses to define the applications and explain them before describing the method for collecting a dataset in case of supporting the usages.

The defined application-1 includes covering the climbers in the mountains and tackling dangerous conditions (such as falling mountains and avalanches, occurring accidents, and disappearing the climbers) by monitoring their vital signs, locations, and weak signals, as shown in Figure 2a. We describe application-2 based on the biosensors’ efficiency in diagnosing cancer and Alzheimer’s by assessing the various types of proteins in people’s blood, which Figure 2b demonstrates its nodes. Figure 2c shows application-3’s nodes when describing detecting the infected people with COVID-19 and dedicating the emergency healthcare services to them. Due to the severe body sensitivities and allergies of the recovered people after infecting cancers, the study dedicates application-4 to monitoring their vital signs for timely identification of the risky conditions and providing the proper services. The application helps to prevent facing anaphylaxis shock by analyzing the Arterial Blood Gas Test (ABG) and coupled protein-G, which ABG consists of O₂, PH, and CO₂ [41,42,43].

According to the defined applications (1)–(4), we collect a dataset of the people’s vital signs in normal and risky conditions and the healthcare services, which consists of the doctor’s treatment recommendations, hospital, emergency, clinic services, etc. The study utilizes the shared valid statistics of the mountaineering stations and the people’s vital signs (including the shared valid outputs of heart rate, blood pressure, sugar level, and location sensors) [44,45,46]. We monitor and analyze the outputs of biosensors and Electroencephalography (EEC) signals to collect a dataset of the physical and information layers for application-2 and register them, which were shared by valid references [47,48,49,50,51]. Due to application-2 and the proposed idea, the collected dataset also includes shared information about the related services to support the issue that covers the recommendations and diagnoses of the expert doctor, blood specialist, and hospital and clinic servers [52,53]. This work estimates the people’s vital signs before and after being infected with COVID-19 and analyzes the appropriate healthcare services for them in dangerous and normal conditions. It utilizes the shared statistics of the disease by the shared credible medical references [54,55].

Moreover, we simulate the applications’ nodes before and after performing NFC and pruning the defective components when analyzing their availability and security by injecting faults with random rates and registering them into the collected dataset (simulated by the CupCarbon tool). Figure 3 demonstrates the research method to collect a dataset, which we share on Github (https://github.com/yasamanhosseini/Flexible-clustering-IoMT-nodes, accessed on 20 July 2022) [56].

3.2. Presenting Equations and Models

We present Equations to describe node-mapping and flexible clustering and provide models to estimate availability, security, privacy, and dependability where the subsection addresses the mentioned issues and explains them.

Before addressing the Equations description, we indicate the process of mapping the application’s nodes onto graph vertices and defining its edges based on the relationship between service providers and physical and information layers, as shown in Figure 4a. To identify the appropriate neighbor servers, the study employs a quasi-mapping method to transfer the role of graph vertices and neighbor service providers onto a partial neural network’s neurons via training them with application priority; Figure 4b illustrates the mapping process. We utilize application-1 to indicate node and neural network mapping for clarifying the explanation of the mentioned processes and Equations, as shown in Figure 4a,b. The roles of physical and application layers’ nodes are accumulated and mapped onto a vertex of the graph, which has a relationship with other vertices as the healthcare service providers at the application level. We utilize the role accumulation method to target the research on analyzing the service provider nodes and the relationship between them and other level components of the IoMT-based applications.

The study presents the parameters declaration and definitions of the employed variables in Equations (1)–(13) before their definition and explanation, which

Table 2. The existing parameters in equations.

Parameter	Description	Condition
A	Matrix of Graph A	—
U	Matrix of neural network’s input layer	—
H	Matrix of neural network’s hidden layer	—
GA	Graph A based on the relationship between physical, information, and integration layers’ nodes and healthcare service providers of an application	—
V	The vertices of Graph A	0 ≥ V
E	The edges of Graph A	0 ≥ E
i	The row number of matrix A	0 ≤ i ≤ imax
j	Column number of matrix A	0 ≤ j ≤ jmax
p	The row number of matrix U	0 ≤ p ≤ pmax
q	Column number of matrix U	0 ≤ q ≤ qmax
y	The row number of matrix H	0 ≤ y ≤ ymax
z	Column number of matrix H	0 ≤ z ≤ zmax
pi	Physical, integration, and information layers’ nodes of Graph A	—
sp	Healthcare service provider node of Graph A	—
n	The number of ahealthcare service providers	0 ≤ n ≤ nmax
s	The number of services of the neural network output	0 ≤ s ≤ smax
ai,j	Matrix A’s element	(ai,j = 0) OR (ai,j = 1)
up,q	Matrix U’s element	(up,q = 0) OR (up,q = 1)
hy,z	Matrix H’s element	(hy,z = 0) OR (hy,z = 1)
imax	The maximum number of matrix A’s rows	0 ≥ imax
jmax	The maximum number of matrix A’s columns	0 ≥ jmax
pmax	The maximum number of matrix U’s rows	0 ≥ pmax
qmax	The maximum number of matrix U’s columns	0 ≥ qmax
ymax	The maximum number of matrix H’s rows	0 ≥ ymax
zmax	The maximum number of matrix H’s columns	0 ≥ zmax
nmax	The maximum number of a healthcare service provider	0 ≥ nmax
smax	The maximum number of services of the neural network output	0 ≥ smax
d	The total number of hidden layer’s weights	0 ≥ d
l	The total number of output layer’s weights	0 ≥ l
GraphCondition	The relationship between service providers, physical and integration, and information layers nodes	0 ≥ GraphCondition
XNumber	The threshold number of defective nodes	0 ≥ XNumber
XjoinedNode	The number of newly joined nodes	0 ≥ XjoinedNode
Threshold	The threshold value of application validation based on priority	0 ≥ Threshold
FaultDetection	Detecting faults in the service providers	0 ≥ FaultDetection
ApplicationSituation	Investigating the IoMT application’s situation in fault detection	(ApplicationSituation = 0) OR (ApplicationSituation = 1)
NeuronMapping	Mapping Graph’s nodes onto a neural network neurons	—
OutputN	Output neuron	0 ≤ OutputN ≤ 1
Failedapplication	The situation of faulty service providers	(Failedapplication = 0) OR (Failedapplication = 1)
joinednode	The situation of new joined nodes	(joinednode = 0) OR (joinednode = 1)
Fault	The fault number	0 ≤ Fault ≤ Faultmax
Faultmax	The maximum number of fault	0 ≥ Faultmax
PenaltyFault	The penalty for a fault	0 ≥ PenaltyFault
ThresholdNN	The threshold value of the neural network’s output	0 ≥ ThresholdNN
$Servic{e}_{s_t}$	The service with s number at t time	0 ≥ $Servic{e}_{s_t}$
$WeightN{N}_{hidde{n}_d}$	Hidden layer’s weights’ values with d index	—
$WeightH{L}_{intia{l}_d}$	The initial value of the hidden layer’s weights	—
$WeightN{N}_{outpu{t}_l}$	Output layer’s weights’ values with l index	—
$WeightO{L}_{intia{l}_l}$	The initial value of the output layer’s weights	—
ServiceAvailability	Service availability of the IoMT application	0 ≤ ServiceAvailability ≤ 1
OutputAvailabilityt	The availability of output neuron at t time	0 ≤ OutputAvailability ≤ 1
ServiceSecuritypi	IoMT application security based on pi	0 ≤ ServiceSecuritypi ≤ 1
CorrectServicet	The number of received correct services at t time	—
TotalServicet	The total number of received services at t time	—
ServicePrivacy	A definition of application privacy is based on the relationship between its nodes and security	—
En	The related edge of Graph A to service provider n	—
α	Impact factor of availability on dependability	0 ≤ α ≤ 1
β	Impact factor of security on dependability	0 ≤ β ≤ 1
µ	Impact factor of confidence on dependability	0 ≤ µ ≤ 1
Dependability	IoMT application dependability	0 ≥ Dependability

demonstrates the description of the existing parameters.

To clarify the introduced parameters in Table 1 and the descriptions of Equations (1)–(13), we provide some definitions as follows:

• [A]_i×j demonstrates the matrix of the relationship between vertices of G_A = (V, E), where i and j are indexes of rows and columns number of the matrix.
• G_A = (V, E) consists of V vertices and E edges based on the number of the application’s nodes (Defining vertices) and the relationship between them (Defining edges) where (V = i) and (E = j), and (i = j = n) by describing n as the number service providers and pi node (as the accumulated node of the physical and information layers’ components).
• GraphCondition estimates the sum of [A]_i×j matrix’s elements to investigate the relationship between service providers’ vertices (sp) and pi for utilizing its value to detect fault where a_i,j describes the located element of the matrix in I row and j column.
• Threshold defines a value for each application based on service and their priority for deciding to employ the neighbor servers after detecting faults. Xnumber and sp_n demonstrate the threshold number of defective service providers and the total number of the initial servers of the application.
• FaultDetection estimates a value to detect fault based on the sum of [A]_i×j matrix’s elements (GraphCondition) and the expected value of the GraphCondition parameter, which is evaluated by$\left(i_{max}+j_{max}\right)-1$as the maximum number of rows and columns.
• ApplicationSituation determines the situation of the application after detecting fault based on the estimated threshold’s value by defining the FailedApplication parameter and quantifying it.
• ClusteringVertices categorizes the vertices of G_A (A graph) to cluster them based on two conditions of normal and faulty situations when identifying the application is as correct (Initial clustering) and facing failed application or joining a new service provider (Re-clustering) to application, which the joined node describes the number of new joined servers to application.
• [U]_p×q describes a matrix to define the neurons of a neural network input layer where p and q determine the number of rows and columns of the [U]_p×q matrix.
• [H]_y×z is a matrix to describe the neurons of a NN’s hidden layer with y rows and z columns.
• NeuronMapping describes mapping the initial service provider, neighbor servers, and pi (Accumulated physical and information levels’ nodes) nodes onto the input, hidden, and output layers’ neurons, where u_p,q and h_y,z are the elements of [U]_p×q and [H]_y×z matrices.
• Penalty_Fault estimates the penalty value based on the threshold and output values and the total number of services at t time, where OutputN_t and ThresholdNN indicate the output neuron’s value at t time and the estimated threshold value of the neural network.
• $WeightN{N}_{hidde{n}_d}$computes the value of the hidden layer’s weight after imposing the estimated penalty value onto them by$WeightH{L}_{intia{l}_d}$(the initial value of the hidden layer’s weight) and$Penalt{y}_{Faul{t}_t}$values where d and Fault are the indexes for the weight and the related penalty to the detected fault.
• $WeightN{N}_{outpu{t}_l}$demonstrates estimating the value of the output layer’s weights at the time after imposing the computed penalty onto them where$WeightO{L}_{intia{l}_l}$and$Penalt{y}_{Faul{t}_t}$illustrate the values of the initial output weight and penalty with d and Fault indexes, respectively.
• ServiceAvailability estimates the application availability at t time based on analyzing the output neuron’s value after pruning weak weights and neurons where OutputAvailable demonstrates the availability of the output neuron.
• ServiceSecurity assesses the application security based on the number of correct services received (CorrectService_t) and the total number of services (TotalService_t) at t time.
• ServicePrivacy analyzes the application’s privacy by defining the edges between G_A vertices and removing the related connections to the faulty nodes where ServiceSecurity_pi describes the security of the pi vertex.
• Dependability estimates the application dependability where α, β, and µ are the impact factors of availability, security, and confidence.

According to the above mentioned definitions, we describe analyzing the graph situation by presenting Equation (1). The service providers’ vertices of the GA are updated, including the sp (1)–(n) when detecting the faults and joining the servers to the application by defining or removing the edges between the graph nodes. To clarify the Equations’ descriptions, we use the presented application-1 to define them.

Equation (2) demonstrates estimating a threshold value for each application, which is determined by analyzing the application and service priority, and considering the total number of servers. Due to the equation, we define the specific threshold values for the IoMT applications based on the threshold number of defective nodes when facing more leads to a failure.

$$Threshold=\frac{XNumber}{{{\displaystyle \sum }}_{n=0}^{n=n_{max}}s{p}_n}$$

(2)

By presenting Equation (3), the study detects the faults on the related graph vertices to the mapped service providers’ nodes where $\left(i_{max}+j_{max}\right)-1$ demonstrates the expected edges (connections between sp and pi nodes).

$$FaultDetection=\frac{GraphCondition}{\left(i_{max}+j_{max}\right)-1}\times Threshold$$

(3)

We present Equations (4) and (5) to determine the application situations and cluster the graph vertices based on them, which consists of correct ($Failedapplication=0$) and failed ($Failedapplication=1$) statuses by meeting $\left(FaultDetection\simeq Threshold\right) \vee \left(FaultDetection>Threshold\right)$ and $\left(FaultDetection<Threshold\right)$, respectively. After determining the situation of the application, this work categorizes the graph vertices for the initial and renewed clustering them where the conditions of $\left(Failedapplication=0\right)\wedge \left(Joinednode=0\right)$ and $\left(Failedapplication=1\right)\vee \left(Joinednode=1\right)$ are met, respectively.

To identify the proper service providers in the neighbor clusters after detecting faults on the application nodes, we utilize quasi-mapping methods to transfer the role of graph vertices onto a partial neural network’s neurons by presenting Equation (6). The main and neighbor service providers are mapped onto input and hidden layers’ neurons via meting $\left(0\le i\le i_{max}\right)\wedge \left(1\le j\le j_{max}\right)$ and $\left(i_{max}<i\le i_{max+XNumber}\right)\wedge \left(j_{max}<j\le j_{max+XNumber}\right)$ conditions.

$$\begin{gathered} U=\left[\begin{array}{ccc}{u}_{0,0}& \dots & u_{0,q}\\ ⋮& ⋮& ⋮\\ u_{p,0}& \dots & u_{p,q}\end{array}\right] H=\left[\begin{array}{ccc}{h}_{0,0}& \dots & h_{0,z}\\ ⋮& ⋮& ⋮\\ h_{y,0}& \dots & h_{y,z}\end{array}\right] \\ \begin{array}{l}NeuronMapping\\ =\{\begin{array}{l}{u}_{p,q}=a_{i,j}, (0\le i\le i_{max})\wedge (1\le j\le j_{ma\mathrm{x}})\\ h_{y,\mathrm{z}}=a_{i,\mathrm{j}}, (i_{ma\mathrm{x}}<i\le i_{ma\mathrm{x}+XNumber})\wedge (j_{ma\mathrm{x}}<j\le i_{ma\mathrm{x}+XNumber})\\ OutputN=a_{0,0}\end{array}\end{array} \end{gathered}$$

(6)

Equation (7) illustrates computing a threshold value for analyzing the situation of the output neuron and deciding to impose a penalty on the trained initial weights after mapping the partial neural network.

$$Penalt{y}_{Fault}=\frac{{{\displaystyle \sum }}_{t=0}^{t=t_{max}}\left(Output{N}_t-ThresholdNN\right)}{{{\displaystyle \sum }}_{s=0}^{s=s_{max}}\left(Servic{e}_{s_t}+1\right)} , 0\le t\le t_{max}$$

(7)

We impose the estimated value of the related penalty to the detected fault into the initial weights of the hidden and output layers by presenting Equations (8) and (9).

$$\begin{array}{l}d=p_{max}\times q_{max}\\ l=y_{max}\times z_{max}\\ WeightN{N}_{hidde{n}_d}=WeightH{L}_{intia{l}_d}-{{\displaystyle \sum }}_{Fault=0}^{Fault=Faul{t}_{max}}Penalt{y}_{Faul{t}_t} , 0\le t\le t_{max}\end{array}$$

(8)

$$WeightN{N}_{outpu{t}_l}=WeightO{L}_{intia{l}_l}-{{\displaystyle \sum }}_{Fault=0}^{Fault=Faul{t}_{max}}Penalt{y}_{Faul{t}_t}, 0\le t\le t_{max}$$

(9)

To assess the application availability, the study presents Equation (10) to appraise the parameter for service providers based on analyzing the output neurons’ values and the number of unavailable servers.

$$ServiceAvailability=\frac{1}{{{\displaystyle \sum }}_{t=0}^{t=t_{max}}{\left(1-OutputAvailable\right)}_t}$$

(10)

Equations (11) and (12) are provided to compute and evaluate services security and privacy to estimate the mentioned characteristics of the application by investigating the output neuron’s values, and the number of the received correct services at t time. We define and estimate the application privacy by removing the related edges to the detected defective service providers’ nodes.

$$ServiceSecurit{y}_{pi}=\frac{{{\displaystyle \sum }}_{t=0}^{t=t_{max}}CorrectServic{e}_t}{TotalServic{e}_t}$$

(11)

$$ServicePrivacy=\{\begin{array}{c}{E}_n:pi\leftarrow s{p}_n, ServiceSecurit{y}_{pi}\simeq 1\\ E_n:pi\leftarrow 0, ServiceSecurit{y}_{pi}\ne 1\end{array}$$

(12)

Application dependability parameter depends on availability, security, and confidence with the different impact factors (α, β, and µ), which directly relate to service priority, as shown in Equation (13). To determine the mentioned impact factors, we define the weights that are demonstrated the role of service availability, security, and confidence based on application priorities. Equation (13) evaluates the application dependability after applying the values of α, β, and µ.

$$\begin{gathered} \left(\alpha +\beta +\mu \right)=1 \\ Dependability=\alpha \left(ServiceAvailability\right)+\beta \left(ServiceSecurity\right)+\mu \left(\frac{{{\displaystyle \sum }}_{t=0}^{t=t_{max}}ConfidenceService}{TotalServic{e}_t}\right) \end{gathered}$$

(13)

3.3. Node Mapping and Flexible Clustering Algorithm

The case study presents a four-phase intelligent algorithm to map the application’s nodes onto graph vertices and transfer their role onto the neural network’s neurons for identifying the appropriate service providers in the neighbor clusters by applying the service priority to the NN’s weights. After mapping the graph nodes and defining their edges based on the relationship between service providers and other application components, NFC categorizes the vertices for clustering them to timely fault detection and tackle them. The algorithm’s four phases cover node mapping onto the graph vertices and initial clustering them, role transferring onto a partial NN’s neurons, detecting the defective service providers, and training neural network and re-clustering. To clarify explaining NFC’s operations, we utilize application-1 and declare the algorithm inputs, outputs, and parameters where Algorithm 1 demonstrates the mentioned descriptions. Application-1 consists of four service providers (sp) and five physical and information (pi) layers’ nodes, which are employed the characteristics to define the index number of the graph’s vertices, as shown in Algorithm 1.

Algorithm 1 Node mapping and flexible clustering (NFC)
Inputs:	1-PIS: The node’s values of the Physical and information and integration layers (HeartRateSensor, SugarLevelSensor, BloodPressureSensor, GPSSensor, DoctorService, NurseService) whereas PIS⸦ Natural number
	2-HSP: The nodes’ value of healthcare service providers (ClimbingStationService, MauntaieeringReliefService, EmergencyService, PoliceStationService)
Output:	ApplicationDependability: The output’s value for analyzing the application dependability whereas 0 ≤ ApplicationDependability ≤ 1
Parameter declaration: PI: Physical sensor and integration service = {HeartRate, SugarLevel, BloodPressure, GPS, Doctor, Nurse} SP: ={ClimbingStation, MountaineeringRelief, Emergency, PoliceStation} pi: ={0, 1,…, 4, 5} s: ={1, 2, 3, 4} i: Row index = {0, 1, 2, 3} j: Column index = {0, 1, 2, 3} nc: Neighbor cluste = {0, 1, 2} p: ={0, 1,…, 4, 5} q: ={0, 1,…, 4, 5} x: Neighbor node whereas x ⊂ Natural number and x ≥ 0 y: Joined node whereas y ⊂ Natural number and y ≥ 0 t: Available time whereas t ⊂ Natural number and t ≥ 0 α: The impact factor of IoMT application availability whereas α ⊂ Binary number β: The impact factor of IoMT application security whereas β ⊂ Binary number µ: The impact factor of IoMT application confidence whereas µ ⊂ Binary number

In phase 1, NFC first maps and accumulates the role of physical and information layers’ nodes to a graph’s vertex for addressing the relationship between it and service providers to timely identify the defective servers. After mapping the application’s nodes onto graph vertices and defining its edges, we categorize the primary nodes for initial clustering to simplify analyzing the efficiency and detecting faults. The algorithm identifies the new joined nodes to the application and relevant service providers of the neighbor clusters to the faulty devices where (NewJoinedNode = True) and (CreatConnetionBetweenGraphNode0AndGraphNodes = True) are met, as shown in Algorithm 2.

Algorithm 2 NFC’s phase 1

Phase 2 supports the neural network mapping operations to transfer the role of graph vertices onto the NN neurons to identify the appropriate neighbor service providers and decide about dedicating or joining them to the cluster after detecting faulty components. Algorithm 3 demonstrates the quasi-mapping operations of phase 2 of the proposed algorithm. We map the new joined components to the application and neighbor service providers onto the hidden layer neurons, which the role of physical and information levels’ nodes (pi vertex) for transferring to the output neuron. NFC transfers the role of the essential service providers’ vertices of the graph onto the input layer’s neurons of a partial neural network where (InputLayerNeuron) _i,j ← ${\left(\mathrm{GraphNode}\right)}_{\left(\left(3\times j\right)+i\right)+1}$ operation is performed.

Algorithm 3 NFC’s phase 2

In phase 3, the algorithm addresses detecting faulty service providers and identifying the proper neighbor components to re-clustering the graph vertices and cover the operations of failed nodes, as shown in Algorithm 4. After mapping the neurons and detecting faulty nodes, NFC starts training the neural network based on the application and service priority by applying them and estimated penalty values into the NN’s weights when (FaultDetection < Threshold) is met. By imposing the penalty values into the weights and re-training the neural network, we prune the weak neurons and weights, which re-cluster the graph vertices based on the joined or removed nodes by fulfilling the (NewJoinedNode = True) condition.

Algorithm 4 NFC’s phase 3

Due to the phase 4 operations, we estimate the application dependability by evaluating availability, security, and confidence, which depend on service priority. NFC investigates the application and service priority to assess the availability, security, and confidence by defining the different impact factors of α, β, and µ when Algorithm 5 indicates the mentioned operations of phase 4. The algorithm starts computing the application’s availability and security based on Equations (10) and (11) where ((ApplicationPriority = ServiceAvailability), (Timely receiving service degree ≤ Threshold value)), ((ApplicationPriority = ServiceSecurity), and (Timely receiving service degree ≤ Threshold value)) are fulfilled. By meeting the (ApplicationPriority ≠ Confidence) condition, NFC resets the related impact factor to the confidence for deactivating the parameter in estimating the application dependability.

Algorithm 5 NFC’s phase 4

To clarify the NFC operations and explanations, we try to illustrate pruning the faulty nodes and re-clustering the graph vertices based on the joined and removed service providers by defining the four hypotheses and implementing them in the applications (1)–(4). Figure 5, Figure 6, Figure 7 and Figure 8 show the four hypotheses that are implemented in the applications (1)–(4) by considering their priority in analyzing their dependability. According to the algorithm operations, we first determine the failure situation for application-1, prune the defective service providers, and re-clustering the graph vertices by analyzing the threshold value and identifying the appropriate neighbor node, as shown in Figure 5a,b. Its application priority is availability that NFC identifies the available neighbor service provider to join the cluster and cover the defective components by training the neural network and pruning the irrelevant server.

By evaluating application-2 priority, the algorithm starts applying service priority, imposing the penalty value onto the neural network weights, and re-training it to decide the appropriate neighbor servers after detecting faulty nodes and failure situations. Security is defined as the application-2 priority because of the risky conditions of the patients with Alzheimer’s and cancer to receive a secure healthcare service. We prune the weak neurons and weights to identify the secure neighbor servers and re-cluster the graph vertices after passing the mentioned operations when Figure 6a,b illustrate the fault hypothesis for application-2.

Due to the estimated threshold value to application-3 and its priority, NFC identifies the neighbor service providers, covering the security and availability by imposing penalties on the weights and re-training the neural network. The algorithm starts the re-clustering phase due to the fault hypothesis and passes the condition of detecting the failure situation, as shown in Figure 7a,b. Application-4 supports the patients with COVID-19, in which the priority consists of the security and availability because of facing the risky conditions of the infected people and the high prevalence rate of the disease.

Figure 8a,b indicate the fault hypothesis for application-4 and the phases-passing of NFC after detecting the faulty service providers and re-clustering the graph vertices. The availability characteristic is the application-4 priority by considering the dangerous and specific conditions of the recovered patients with cancer and their severe allergies and weak immune systems.

An overview of the existing explanations of NFC and additional information on its operations proves the significant effect of the algorithm on improving the efficiency of the IoMT applications by employing the appropriate neighbor servers and stopping the defective components. The algorithm improves the privacy and dependability of the different IoMT-based applications by applying the service priority to decision making about dedicating the appropriate healthcare servers and joining them to a cluster to cover the operations of the defective nodes. Moreover, we remove the imposed energy consumption and communication delay overheads of the failed or faulty devices to the performance of the applications and improve it by pruning or stopping the defective service providers.

4. Simulation Results and Observations

The section analyzes the proposed algorithm and Equation efficiency in satisfying the mentioned purposes of the study and improving the performance and dependability of the IoMT applications. To follow the issue, we report the availability, dependability, and total delay and energy of applications (1)–(4) before and after performing NFC and pruning the faulty service providers and replacing them with the neighbor servers. The study utilizes the CupCarbon tool to simulate the applications for analyzing the efficiency of NFC and flexible-clustering in improving the performance of the IoMT via describing their nodes by Java and Python co-designs [26,57,58]. We evaluate the dependability, security, and availability of the applications’ nodes via injecting fault with random rates by the simulator, which runs on the Ubuntu-LTS 16.04 and MAC operational systems [59,60]. The study reports the estimated availability, dependability, and performance of the applications by exerting the mentioned hypotheses (Section 3) on their simulations.

This work employs a partial neural network to map the server nodes onto the NN’s neurons and train them by considering the application and service priority to identify the proper service providers in the neighbor clusters. We train the neural network based on the Gradient Descent method and utilize the rectified linear unit (ReLU) activation function to generate the outputs where NN is described by the Python co-design and TensorFlow library on the Jupyter notebook [58,61,62]. The neural network is learned and generates outputs before and after imposing the estimated penalty values into the NN’s weights by the supervised learning-based methods. This work determines the number of NN’s hidden layers based on the total number of neighbor clusters to map their service providers on their nodes for deciding on the appropriate servers by pruning the weak neurons and weights.

Due to the relationship between fault injection rate and application availability, we compare the characteristics to verify the reported simulation results after detecting fault service providers and pruning or stopping the servers’ nodes, as shown in Figure 9a–d.

Availability is defined as the application and service priority for the defined applications (other than application-2) because of the highlighted role of timely providing services to the requesters. The simulation results indicate the indirect relationship between the parameter and fault injection rate. The security characteristic has an impressive effect on improving the efficiency of application-2 when the observations demonstrate the faint role of increasing fault injection rate on deteriorating the application availability (as shown in Figure 9b).

Figure 10a–d illustrate the dependency between rising fault rate and falling the dependability of applications (1)–(4) to verify the presented simulation results and Equation (13) efficiency in estimating the addressed parameter.

Figure 11a–d illustrate the role of applying NFC and the proposed idea in improving the dependability of applications (1)–(4) by approximately 77.3–83.2% compared with other approaches (Before NFC). We consider the application and service priority to analyze the efficiency of the applications and define a specific threshold value to decide their situation for re-clustering the graph vertices. After detecting the faulty service providers and determining the failed situations, NFC stops the connections between the servers and other nodes of the applications by identifying the proper neighbor devices and pruning their inappropriate cases. By applying the mentioned operations, the study improves the dependability of the different IoMT applications compared with other recent methods because of their lack of support from the priority feature.

This work pays attention to improving the efficiency of the IoMT application by providing an intelligent algorithm to raise the performance and dependability. To increase the performance of the applications, we prune the faulty nodes and remove their delay and energy consumption overheads, where Figure 12,b demonstrate improving the parameters about 19.3–21.7% and 10.3–11.8% for applications (1)–(4) compared with lack of employing NFC (Without NFC). The study simulates the applications’ nodes and reports the total delay and energy before and after performing the algorithm and pruning the faulty components with the CupCarbon tool. The recent case studies ignored imposing latency and energy consumption overheads of the failed devices on the performance of IoMT-based applications. This work aims to remove the destructive parameters and improve their efficiency. The simulation results prove the highlighter role of the pruning method in reducing the total delay than the energy consumption because of replacing the failed nodes with the neighbor components.

The above reported simulation results and their analysis evidence the impact of NFC and other research steps on improving the dependability, privacy, and performance of the IoMT applications. The study targeted the simulation results to analyze the performance and dependability of applications (1)–(4) with different service priorities and properties to prove supporting various IoMT applications by employing the algorithm. NFC covered the risky and normal conditions for providing dependable service to the requesters and patients to prevent a dangerous situation by failing the servers and applications. We supported the application’s privacy by stopping forwarding and transferring malicious data between the server and sensor nodes to remove the related graph’s edges to the defective vertices. NFC created the opportunity to improve the application dependability by re-clustering and updating the graph vertices to timely detect faulty service providers and failed statuses, which were replaced with the appropriate neighbor components. Moreover, the algorithm affected improving the IoMT applications’ performance by removing the defective nodes’ energy consumption and latency overheads via employing the neural network and pruning its weak weights and neurons.

Apart from proving the idea’s efficiency in improving the IoMT-based applications’ performance, we analyze its role when facing vehicle service providers in a specific scenario. NFC can detect the proper vehicle HSs to join a cluster after exiting the verified domain, which leads to challenges of losing services and risky situations by assigning a task. Due to the addressed problem scenario, we define the conditions for the joined devices to overcome the challenges by considering the stations to cluster them and time limitation (Time availability margin) for vehicle healthcare service providers.

We obtain the logs of the CupCarbon simulations and short movies of running the applications and injecting faults with random rates that shared them on Github (https://github.com/yasamanhosseini/Flexible-clustering-IoMT-nodes, accessed on 20 July 2022) to verify the reported results [56].

5. Conclusions

The IoMT technology appeared to solve the problem of supporting the security and private records on the IoT-based E-healthcare systems by raising the variates of the joined applications to the IoT infrastructures. To grow up the IoMT-based applications, protecting the patients’ private records and doctors’ treatment recommendations is challenging for the technology by increasing the complexity and communication between its layers and nodes. The recent case studies addressed solving the issue and presented the different approaches and algorithms to satisfy the IoMT security. The inconspicuous role of application and service priority creates some limitations for providing their ideas. Aside from the negative impact of the faulty nodes on the IoMT’s dependability, their total energy and delay overheads hurt the performance of the technology. This work tried to overcome the mentioned problems and improve the efficiency of the IoMT-based applications by considering the application and service priority in providing the idea. We presented an intelligent algorithm, Equation, and model to detect the defective service providers and utilize the proper neighbor servers to support the operations of the failed nodes. The study improved the dependability of the IoMT applications by timely detecting defective components via providing a flexible clustering method to categorize the appropriate service providers. By pruning or stopping the faulty servers, we removed the energy consumption and communication delay overheads of the failed nodes from the performance of the applications.

Flexible clustering can create an opportunity to identify the domain of high, low, and empty demands and classify them toward decision-making about dedicating the fixed healthcare service providers. The scope can be followed to timely predict and detect the faulty devices in the clusters and fail them based on a threshold value, which helps to define flawless sub-clusters and improve the dependability of IoMT applications. Due to the energy efficiency and latency, the approach can also affect detecting the highly cost-based clusters, balancing load onto their devices, and accelerating the task and flow-mapping onto the network nodes by re-clustering IoMT devices.