SAFE-CAST: secure AI-federated enumeration for clustering-based automated surveillance and trust in machine-to-machine communication

Process of federated clustering

Federated clustering involves the following key steps:

1. Local clustering: Each machine, or node, in the network performs local clustering based on its observed data and interactions. This step involves grouping neighboring nodes that frequently communicate and exhibit similar trust values and behaviors. Local clustering algorithms, such as K-means or DBSCAN, can be employed for this purpose.

2. Cluster head selection: Within each local cluster, a CH is selected. The CH is responsible for aggregating data from its cluster members and communicating with other CHs. The selection of CHs can be based on criteria such as trust values, computational capabilities, and energy levels to ensure that the most suitable nodes take on this role.

3. Federated aggregation: CHs participate in a federated learning process, where they aggregate the data and models from their respective clusters. This step involves sharing and updating a global model without transferring raw data, thereby preserving data privacy and reducing communication overhead.

4. Global model update: The aggregated models from CHs are used to update a global model, which is then distributed back to the CHs. This global model helps maintain consistency and improve the overall performance of the network.

5. Iterative refinement: The process is iterative, with multiple rounds of local clustering, aggregation, and global model updates. Each iteration refines the clusters and improves the accuracy and efficiency of the overall system.

Benefits of federated clustering

Federated clustering offers several benefits for M2M communication networks:

• Enhanced security: By decentralizing the clustering process, federated clustering reduces the risk of single points of failure and makes it more difficult for attackers to compromise the entire network.

• Data privacy: Since raw data is not transferred during the federated learning process, federated clustering preserves data privacy and complies with data protection regulations.

• Scalability: Federated clustering is inherently scalable, as it distributes the computational load across multiple nodes and reduces the need for centralized coordination.

• Efficiency: By leveraging local computations and reducing the volume of data exchanged between nodes, federated clustering improves the efficiency and reduces the communication overhead of the network.

Implementation of federated clustering

The implementation of federated clustering in the proposed framework involves several key components:

• Local clustering algorithms: The framework utilizes local clustering algorithms, such as K-means or density-based spatial clustering of applications with noise (DBSCAN), to group nodes based on their interactions and trust values.

• Cluster head selection mechanism: A selection mechanism is employed to identify the most suitable nodes to serve as CHs. This mechanism considers factors such as trust values, computational capabilities, and energy levels.

• Federated learning framework: A federated learning framework is used to aggregate and update models from CHs. This framework ensures that data privacy is preserved and that the global model is continuously improved.

• Communication protocols: Efficient communication protocols are implemented to facilitate the exchange of models and updates between CHs and the central aggregator. These protocols minimize communication overhead and ensure timely updates.

• Security measures: The framework incorporates security measures, such as encryption and authentication, to protect the integrity and confidentiality of the data exchanged during the federated learning process.

Initially, wireless M2M machines are capable of communicating with each other and continuously seeking services in a real-time environment. In this setup, the machines are clustered by adopting federated learning (FL) to improve data privacy and machine secrecy. For clustering, a local model is generated based on individual machine factors such as distance, energy, density, degree, and stability. This local model is then encoded using Lagrange encoding, and the coded data is privately shared with the edge server using theoretical information. After manipulating the algebraic structure of the coding, FL implements Lloyd’s K-means algorithm on the coded data to acquire clustering results. Once the machines are clustered, the cluster head is selected.

We have intensified throughput and energy efficiency, thus minimizing overhead and premature CH death, by implementing dual CH selection. CH selection is based on multiple parameters such as distance, energy, capacity, feedback, density, packet delivery ratio (PDR), and trust. The machines in each cluster are ranked on the basis of these parameters. The machine ranked first is selected as the CH, and the machine ranked second becomes the sub-CH. As a result, intra-communication is performed by the sub-CH, where M2M communication inside the cluster is executed by the sub-CH. Similarly, inter-communication is accomplished by the CH, involving CH-to-CH communication and CH-to-edge server communication. This approach improves the throughput and energy efficiency of M2M communication.

Lloyd’s K-means algorithm

Lloyd’s K-means algorithm, a widely used local search technique for clustering, has been a staple in many ML studies due to its effectiveness and simplicity. The algorithm starts by selecting k random centers from the dataset, where k represents the number of clusters to be formed. These initial centers are chosen randomly from all samples, and then the samples are assigned to one of these k clusters based on their proximity to these centers.

Lloyd presented a local search technique for clustering K-means. Since it is one of the most widely used algorithms, most ML studies employ it as their primary clustering method. Beginning with k randomly chosen centers, Lloyd’s approach selects k samples at random from all of the samples and allocates them to k clusters or data sets at random. Relocate the centers to the centroid of the newly created clusters after allocating each sample to the closest center. Assign and recompute the center until convergence is achieved by repeating these two procedures. The Algorithm 1 has described the complete process.

 
__________________________ 
 Algorithm 1: Lloyd’s K-means Algorithm                                                   _________ 
    Input: data matrix Z ∈ Sa×m, cluster number k 
    Output: Clustered data points 
    /* Initialization                                                   */ 
 1  Randomly choose k centers; 
  2  while no convergence do 
        /* Step 1                                                        */ 
3   According to Equation 2, update the indication matrix Y ; 
4   Allocate each point to the nearest center; 
   /* Step 2                                                        */ 
5   Assign the k centers to the new clusters’ centroid; 
6   Update matrix X in Equation 2;    

K-means algorithm

Given a data matrix Z ∈ S^a×m that consists of m samples z₁, z₂,….. z_n. The goal of the K-means clustering problem is to find a partition π = {π₁, π₂……π_k} such that the total square distance between each point and its nearest center is as little as possible. We can formulate the problem as: (1)${\displaystyle X^{-}\sum _{i=1}^k\sum _{z_i\in {\pi }_i}^{}\left|\right|z_i-x_i{||}_2^2}$

where x_i denotes the centroid of the cluster π_i. Considering the definitions of indicator matrix Y and squared Fronten is norm. Afterwards, the K-means clustering issue may be expressed as (2)${\displaystyle {min}_{YϵInd,X}\left|\right|z-X{Y}^S{||}_Y^2}$

where X = $\left[x_1,x_2,\dots ..x_k\right]$ ∈S^a×m is the center of the k-clusters, Y is the indicator matrix, and Y ∈S^m×k.

Quality diversity optimization algorithm

Quality-diversity (QD) optimization algorithms tackle a unique set of problems in the realm of optimization. Contrary to traditional methods that aim for the optimum of a cost function, QD algorithms provide a spectrum of effective solutions differentiated by a few user-defined characteristics. These characteristics are chosen based on their relevance and significance to the user, who might be influenced by factors like design simplicity or manufacturing feasibility. Users can then select the most appealing solutions from this diverse pool, guided by their own expertise and the insights gained from the variety of solutions. This approach is especially useful in understanding the interplay between different solution attributes and their impact on performance. QD algorithms thus offer a broader perspective, enabling users to explore a wide range of effective solutions rather than focusing on a single optimal point. (3)${\displaystyle e_{\theta },a_{\theta }\leftarrow e\left(\theta \right).}$

This equation represents the core concept of QD optimization, where e_θ and a_θ signify the evaluation and attributes of the solutions based on the parameters θ. The function e(θ) encapsulates the evaluation or generation of solutions, reflecting the diversity-centric approach of QD algorithms.

It is assumed that the objective function yields a behavioral descriptor (or feature vector) a_θ in addition to the fitness value e_θ. While the fitness value e_θ measures the solution’s effectiveness, the behavioral descriptor (BD) typically explains how the solution addresses the issue.

Looking ahead, the objective function is expected to be maximized while also maintaining generality. The aim of QD optimization is to identify the parameters θ that yield the highest fitness value for each point a in the feature space A. This can be defined as: (4)${\displaystyle \forall a\in A{\theta }^{\ast }={argmax}_{\theta }{e}_{\theta }}$ where a= a_θ. The equation represents the goal of QD optimization to find the optimal parameters θ that maximize the fitness value e_θ for each distinct behavioral descriptor a within the feature space A. This approach enables a comprehensive exploration of the solution space, taking into account both the effectiveness of solutions and the diverse ways they address the problem.

Upon initial observation, QD algorithms might appear akin to multitask optimization, as they seem to address an optimization issue for every possible combination of features. The QD problem is essentially a series of optimizations, each constrained by a specific BD. This is particularly challenging because, firstly, the feature space A could be continuous, leading to an infinite number of problems, and secondly, the BD is unknown prior to the application of the fitness function.

A key aspect of QD algorithms is the collective approach to these numerous optimization problems, which is often more efficient than conducting separate constrained optimizations. The sharing of information between optimizations is beneficial, especially since solutions with similar feature descriptors are likely to perform well.

The effectiveness of a QD algorithm is measured by two primary criteria:

1. The quality of the resultant solution for each type of solution reflects the degree of optimization achieved.

2. The coverage of the feature space indicates how extensively the behavior space is explored.

The outcome of QD optimization is a diverse set of solutions. This collection, also known as a “collection”, “archive”, or “map”, expands, evolves, and improves throughout the optimization process. Each point in this collection represents a distinct “species” or “type” of solution, offering a varied perspective on potential solutions.

Traditionally, evolutionary algorithms focus predominantly on the fitness value or quality for decision making, often overlooking the global optimum and the diversity of solutions. In contrast, QD algorithms consider multiple factors to explore the behavior space (diversity) more thoroughly. The QD-optimization algorithm, encompassing I iterations, is detailed in Algorithm 2 , showcasing its approach to balancing both quality and diversity in solutions.

 
_______________________________________________________________________________________________________________________ 
  Algorithm 2: QD-Optimization algorithm (I iterations)                                 _________ 
  1  C ←∅; 
  2  for iter = 1 → I do 
     3   if iter == 1 then 
    4   Rparents ← random(); 
5   Roffspring ← random(); 
6   else 
    7   Rparents ← selection(C,Roffspring); 
8   Roffspring ← variation(Rparents); 
9   foreach θ ∈ Roffspring do 
    10   {eθ,aθ}← e(θ); 
11   if ADD_TO_CONTAINER(θ,C) then 
12   UPDATE_SCORES(parent(θ), Reward, C); 
13   else 
14   UPDATE_SCORES(parent(θ), -penalty, C); 
15   UPDATE_CONTAINER(C); 
16  return C;    

Reinforcement learning

Automation in machines is predominantly based on reinforcement learning (RL), as illustrated in Fig. 2. In this framework, agents operate within an environment guided by intelligent rules and a reward system. The agents engage in a balance of exploitation and exploration, learning about their environment through continuous trial and error in their actions. This process of exploration and exploitation continues until the agents become adept at performing the relevant activities, effectively adapting their behavior to maximize the cumulative reward or achieve specific objectives within the environment.

Multi-agent reinforcement learning

To complete a task faster, MARL uses autonomous, interactive systems operating in a shared environment. As a result, agents with centralized training carry out dispersed tasks. Applications for MARL systems are found in many different fields, such as distributed control, network administration, game creation, and decision support systems.

Deep deterministic policy gradient

The DDPG algorithm tackles the continuous action space reinforcement learning problem. Its main procedure includes: first, storing the experience data generated as the agent interacts with the environment in the memory of past experiences. Additionally, the actor-critic architecture is utilized to obtain and preserve the sampled data, leading to the determination of the optimal course of action. Figure 3 illustrates the structure of the DDPG algorithm.

In the DDPG approach, which is based on the deterministic policy gradient, the DL method is applied to a neural network that replicates the Q and policy functions. The DDPG algorithm, underpinned by the actor-critic architecture, maintains the organizational structure of the deep Q-network (DQN) algorithm. The actor and critic modules in DDPG can use the online network and target network structures, combining these with the actor-critic approach in the DQN method.

During training, the agent in state C selects Action A using the current actor-network. It then calculates the current action’s P value and the expected return value, x_j= T + γP′, based on the current critic network. The actor target network selects the best action A′ based on past learning experiences, while the critic target network calculates the P′ value of the subsequent action. The online network parameters of the relevant module are frequently updated to reflect changes to the target network’s parameters.

To update the target network parameters, DDPG employs a “soft” approach, meaning each change to the network parameters is made with very little magnitude, which enhances the training process’s stability. The update coefficient is represented by τ, and the “soft” update method can be written as Eq. (5): (5)${\displaystyle {\omega }^{{}^{\prime }}=\tau \omega +\left(1-\tau \right){\omega }^{{}^{\prime }}{\theta }^{{}^{\prime }}=\tau \theta +\left(1-\tau \right){\theta }^{{}^{\prime }}.}$

Using the deterministic policy π, DDPG determines the action to be implemented. The objective function, which approximates the state-action function, is represented using a value network. This function is defined as the cumulative reward with a discounted factor, as shown in Eq. (6): (6)${\displaystyle K\left(\theta \right)=B_{\theta }\left[e_1+\gamma e_2+{\gamma }^2{e}_3+...\right].}$

In this equation, K(θ) represents the objective function with respect to the policy parameters θ. The term B_θ reflects the baseline function or the expected value under the policy π. The elements e₁, e₂, e₃, … denote the sequence of rewards obtained from the environment, and γ is the discount factor, which quantifies the importance of future rewards compared to immediate ones. This formulation allows DDPG to effectively balance immediate and long-term rewards, optimizing the policy towards more beneficial outcomes over time.

Equation (7) delineates the updating process for the critic’s online network’s parameters, focusing on minimizing the mean square error of the loss function. This equation is essential in the training phase, where the goal is to optimize the critic network to accurately predict the value of state-action pairs: (7)${\displaystyle K\left(\omega \right)=\frac{1}{n}\sum _{k=1}^n{\left(x_k-P\left(\varnothing \left(C_k\right),A_k,\omega \right)\right)}^2.}$

In this equation, K(ω) represents the loss function with respect to the critic network parameters ω. The term x_k is the target value for the k-th data sample, and P(∅(C_k), A_k, ω) is the prediction of the critic network for the k-th state-action pair (C_k, A_k). The loss function computes the average of the squared differences between the target values and the network’s predictions over n samples. Minimizing this loss function helps calibrate the critical network to estimate the value function associated with the policy better.

Equation (8) illustrates how the network parameters for the actor online network are adjusted based on the policy’s loss gradient. (8)${\displaystyle {\nabla }_k\left(\theta \right)=\frac{1}{n}\sum _{k=1}^n\left[{\nabla }_{a}P\left(C_k,a_k,\omega \right){\nabla }_{{\theta }_{\pi }}\right].}$

Adaptive multi-agent reinforcement learning for context-aware transmission

The AMARLCAT system, when compared to advanced DDPG-based MARL systems, demonstrates significant improvements in reducing convergence time and enhancing converged performance. Additionally, it surpasses traditional MAC methods in performance. One notable advantage of AMARLCAT is its adaptability, offering various QoS options. Extensive simulations have been conducted to evaluate different state space definitions and metrics, with AMARLCAT showcasing scalability and resilience in all tested scenarios.

The foundation of most reinforcement learning algorithms is the idea of an iterative approach. These algorithms use what are known as temporal-difference updates to spread knowledge about state-action pairings, Q(s, b), or values of states, V(s). The basis for these updates is the difference between the two temporally distinct estimations of a certain state or state-action value. It updates state-action values in the environment after each real transition, (s, b) → (s′, r), using the following formula: ${\displaystyle Q\left(s,b\right)\leftarrow Q\left(s,b\right)+\delta \left[r+\gamma Q\left(s^{\prime },b^{\prime }\right)-Q\left(s,b\right)\right]}$ where the discount factor γ and the rate of learning δ are given. Once an action is completed and the environment returns a reward r, it moves to a new state s′, and action b is selected in state s′. This changes the value of acting in state s.

Balancing discovery and utilization is key to developing effective reinforcement learning agents. It seeks to provide an equilibrium between the exploiting of the agent’s knowledge and the enriching exploration of the agent’s knowledge. Commonly, an agent will usually behave greedily, but it will choose an action at random with a chance of ϵ. This kind of behavior is known as ϵ-greedy. Reduce ρ over time to get the most out of both exploration and exploitation.

There are two main ways that reinforcement learning is used in multi-agent systems: joint action learners or multiple individual learners. Previously, single-agent reinforcement learning algorithms were used to deploy numerous agents for each task. In the latter case, an agent watches the activities of other agents and communicates its actions to the others. This approach comprises specialized algorithms designed for multi-agent scenarios, considering the interactions between multiple agents.

The environment seems to be dynamic since the likelihood of transition when taking action in a state varies over time when multiple individual learners believe any other agents to be a part of the environment. Joint action learners were created to expand their value function and take into account each state’s potential combination of actions by elements to overcome the illusion of a dynamic environment. The number of values that need to be computed increases exponentially with each new addition to the system due to the joint action consideration. Therefore, our study focuses on many multiagent learners since we are interested in scalability and minimum communication latency between agents.

The AMARLCAT system comprises two primary components: setting up a database and the modification of the transmission overhead m. The first step involves obtaining the best transmission policy under the current transmission overhead by inputting m and the state after training. This process leads to the creation of an offline database, where the transmission overhead m range is determined using empirical values. Each m is trained to collect and store the relative DDPG network attributes θ. Constructing the database requires training M events for every n value, making it a time-intensive process.

However, the second stage of training offers significant time savings. Initially, a starting transmission overhead of M₀ is defined, and the corresponding network parameters θ are retrieved from the stage 1 database. The contention process is then simulated to determine the optimal n. Specifically, after completing single-agent training, all terminals use the existing model parameters for multi-agent training. During this phase, if a terminal detects an idle channel, it sends data with a probability determined by its current instantaneous DDPG output. Following each transmission period, the control unit computes the mean reward and modifies the communication cost according to success/failure signals. The transmission overhead is significantly increased following p_fail consecutive collisions but modestly decreased after p_idle consecutive idle intervals.

The methodology outlined in Algorithm 3 starts with M terminals, where ρ regulates the number of terminals per iteration, and M_targets is the number of competing terminals.

 
_______________________________________________________________________________________________________________________ 
  Algorithm 3: AMARLCAT                                                                     _________ 
    /* Phase 1:  Independent Training for Single Agents                 */ 
   /* Setup                                                            */ 
 1  Agents: Initialize parameters Θn(n=1,...,N) using a normal distribution; 
  2  Control Unit: Define mmax and mmin as upper and lower transmission fees; 
  3  Assign mmin = 500, mmax = 10000, Ntarget = ρN; 
  4  ptx = min( 
    ∘ 
     _____ 2δ 
TsN2target ,   1 ____ 
Ntarget ) 
                ; 
  5  for q = 1 to M do 
     6   for n = 1 to N do 
    7   Perform training of DDPG respecting agent-n with current m, updating Θn; 
8   Record the association between m and Θn in a database; 
9   Increment m by mi; 
    /* Phase 2:  Collaborative Multi-Agent Training                     */ 
   /* Setup                                                            */ 
10  Agents: Reset parameters Θn(n=1,...,N) to those from initial training with m0; 
11  Control Unit: Set initial transmission fee as m0; 
12  for event = 1 to T do 
     13   for n = 1 to N do 
    14   if Agent-n detects an idle channel and DDPG suggests transmission then 
15   Agent-n transmits with probability ptx in the current time slot; 
16   else 
17   Agent-n remains silent in the current time slot; 
18   Rk = Compute the average utility for all agents; 
19   if Sequential transmission failures reach qfail then 
20   Increase m by mu; 
21   else 
22   if Channel sensed idle qidle times consecutively then 
23   Decrease m by md; 
24   else 
25   Keep m constant and proceed to the next event;    

Homomorphic encryption

Homomorphic encryption (HE) is an encryption method enabling certain computations on encrypted data without decryption for specific mathematical operations to be performed on ciphertexts. This process results in the generation of another ciphertext. Importantly, the outcome of these operations on the encrypted text mirrors that of operations performed directly on the plaintext. This gives the effect of having conducted the operations on the plaintext itself without any modification or distortion. The use of this encryption method enables users to interact with encrypted data without needing access to the actual content from the sender or the public key for decryption. HE is particularly valuable in preserving privacy across various applications, including cloud data storage, and in enhancing the security and transparency of elections. Furthermore, it addresses challenges in maintaining the privacy of processes and stored data in databases.

Merkle tree-based blockchain structure

The blockchain consists of blocks, each containing:

• Block header:

  • Previous block hash

  • Merkle root

  • Timestamp

  • Nonce

• Transactions: Trust evaluation events

Each transaction in a block represents a trust evaluation and includes:

• Evaluator ID

• Evaluated ID

• Trust value

• Timestamp

• Evaluation metrics

Merkle tree construction

Figure 4 exhibits the blockchain structure for trust management:

1. Each transaction is hashed using SHA-256. 2. These transaction hashes form the leaves of the Merkle tree. 3. Pairs of leaf nodes are then hashed together to form parent nodes. 4. This process continues until a single hash (the Merkle root) is obtained.

The Merkle root, which is part of the block header, offers a concise summary of all the transactions contained within the block.

Trust value storage and verification

When a machine calculates a new trust value:

1. It creates a transaction and broadcasts it to the network. 2. Nodes validate the transaction and add it to the current block. 3. Once enough transactions are collected or a time limit is reached, a new block is created. 4. The Merkle tree for the block is constructed, and the Merkle root is calculated. 5. The block is then added to the blockchain through the consensus mechanism.

Efficient trust value retrieval

The Merkle tree structure allows for efficient verification of trust values:

1. A machine can request a specific trust value along with its Merkle proof. 2. The Merkle proof consists of the transaction and the minimum set of hashes needed to reconstruct the path to the Merkle root. 3. The requesting machine can verify the transaction’s inclusion in the block by recalculating the Merkle root using the provided proof.

This process allows for trustless verification of individual transactions without needing to download the entire blockchain.

Consensus mechanism

We employ a practical Byzantine fault tolerance (PBFT) consensus mechanism, adapted for our Merkle tree-based structure:

1. A leader node proposes a new block, including the Merkle root in the block header. 2. Validator nodes verify the Merkle root and the block’s validity. 3. If a supermajority of validators approves, the block is added to the chain.

Trust propagation and utilization

Trust propagation leverages the Merkle tree structure:

1. Machines can efficiently query and verify trust transactions for any node in the network. 2. Indirect trust is computed by traversing trust relationships, using Merkle proofs to verify each step in the trust chain.

Before initiating communication, a machine can quickly verify the trustworthiness of potential partners by requesting relevant trust transactions and their Merkle proofs.

Security measures

The Merkle tree structure enhances security:

• Tamper evidence: Any change in a transaction would alter the Merkle root, making tampering immediately detectable.

• Efficient auditing: The Merkle structure allows for quick verification of any transaction’s integrity.

• Reduced storage: Light nodes can participate in the network by storing only block headers (including Merkle roots) instead of full blocks.

Scalability considerations

The Merkle tree structure improves scalability:

• Sharding: Each shard maintains its own Merkle tree-based blockchain.

• Cross-shard verification: Merkle proofs allow for efficient verification of trust data across shards.

• Pruning: Old transactions can be pruned while maintaining the Merkle root for historical verification.

This Merkle tree-based blockchain implementation ensures efficient, secure, and scalable storage and sharing of trust values in the M2M network. It provides a robust foundation for decentralized trust management, capable of handling the dynamic nature of M2M communications while maintaining high levels of security and efficiency.

Efficiency analysis

The efficiency of our system can be theoretically analyzed in terms of power consumption and computational complexity.

Security analysis

The security of our system can be theoretically analyzed in terms of attack resistance and data privacy.

Hyperparameter selection process

We employed a combination of grid search and manual tuning to select the optimal hyperparameters for SAFE-CAST. The primary hyperparameters and their selected values are as follows:

• Number of clusters (k) in Lloyd’s K-means algorithm: 5

• Learning rate for AMARLCAT: 0.001

• Discount factor (γ) for AMARLCAT: 0.99

• Number of hidden layers in DDPG networks: 3

• Neurons per hidden layer in DDPG networks: 256

• Batch size for AMARLCAT training: 64

• Trust update interval: 100 time steps

These values were chosen based on their performance across multiple evaluation metrics, including energy efficiency, throughput, security strength, latency, and packet loss rate.

Sensitivity analysis

To understand the influence of key hyperparameters on the experimental metrics, we conducted a sensitivity analysis by varying each parameter while keeping others constant. Here, we present the results for two critical parameters: the number of clusters (k) and the learning rate for AMARLCAT.

Impact of number of clusters (k).

We varied the number of clusters from 3 to 7 and measured its impact on energy consumption and throughput. Figure 6 shows the results of this analysis.

As observed in Fig. 6, increasing the number of clusters initially leads to improved energy efficiency and throughput. However, beyond k = 5, the benefits diminish, and energy consumption starts to increase due to the overhead of managing more clusters. This analysis justified our choice of k = 5 for the main experiments.

Impact of learning rate in AMARLCAT.

We evaluated the effect of the learning rate on latency and security strength by varying it from 0.0001 to 0.01. The results are presented in Fig. 7.

Figure 7 demonstrates that a learning rate of 0.001 provides the best balance between low latency and high security strength. Lower learning rates result in slower convergence and higher latency, while higher rates lead to instability and reduced security strength.

These sensitivity analyses provide insights into the robustness of SAFE-CAST and justify our hyperparameter choices. They also highlight the importance of careful parameter tuning in achieving optimal performance across multiple metrics.

Impact of trust update interval.

The trust update interval determines how frequently the system updates the trust values of nodes in the network. This parameter is critical for balancing the responsiveness of the trust management system with the computational overhead. We conducted an experiment varying the trust update interval from 50 to 250 time steps and measured its impact on security strength, energy consumption, and latency.

Figure 8 illustrates the trade-offs involved in selecting the trust update interval. A shorter interval (50 time steps) results in higher security strength (99%), but also increases energy consumption (J) (8.8J) due to more frequent computations. Conversely, a longer interval (250 time steps) reduces energy consumption (7.3J), but at the cost of lower security strength (92%) and increased latency (1.4s).

Based on these results, we selected a trust update interval of 100 time steps for our main experiments, as it provides a balance between security strength (98%), energy efficiency (8.2J), and low latency (1.15s). This choice reflects our goal of maintaining high security while optimizing resource usage in M2M networks.

This experiment demonstrates the importance of carefully tuning the trust update interval to achieve the desired balance between security and performance in SAFE-CAST. It also highlights the system’s flexibility in adapting to different security and efficiency requirements by adjusting this parameter.

Energy efficiency

Energy efficiency plays a pivotal role in M2M communication, significantly influencing device longevity and overall performance. To ensure prolonged operation and minimize the need for frequent battery replacements in M2M devices, the optimization of energy consumption is of paramount importance. This entails the implementation of low-power communication protocols, efficient data transmission strategies, and intelligent power management techniques.

The findings pertaining to energy consumption, as illustrated in Fig. 9 and summarized in Table 5, reveal noteworthy insights. In comparison to established methods, such as EDDC with a consumption of 10.2J, LSTM with 12.0J, and the proposed method with 8.0J, it becomes evident that the proposed approach exhibits superior energy efficiency. The advantages inherent in reduced energy consumption within the realm of M2M communication are multifaceted. It mitigates the necessity for frequent energy-related interventions, thereby curbing maintenance expenditures and extending the operational lifespan of energy-dependent devices. Moreover, diminished energy utilization contributes to a diminished environmental footprint, thereby enhancing the sustainability quotient of M2M systems.

Throughput

Throughput, a pivotal metric in the domain of M2M communication, quantifies the quantity of data effectively transmitted through the network within a specified time frame. It serves as a yardstick for assessing the system’s capacity to handle communication requirements and gauges the efficiency of data transmission. The results pertaining to throughput are delineated in Table 6 for reference.

Figure 10 provides a graphical representation of the throughput comparison between the proposed methodology and established methods. The throughput values are as follows: 69,000 bits per second (bps) for EDDC, 65,000 bps for GRADE, and 79,000 bps for the proposed method. When juxtaposed with contemporary approaches, it becomes evident that the suggested approach achieves a superior level of throughput. This heightened throughput enables devices to engage in more rapid and responsive interactions, thereby facilitating real-time data exchange and expediting decision-making processes.

Security strengthen

The enhancement of security in M2M communication is imperative to guarantee the confidentiality, integrity, and availability of transmitted data.

Figure 11 and Table 7 present the results of security enhancement. When compared to existing methods, the proposed approach achieves significantly higher security strength, with values of 85% for EDDC, 71% for GRADE, and an impressive 98% for the proposed method. This heightened security ensures that only authorized devices can engage in communication, mitigating the risk of unauthorized access. The implementation of robust authentication and encryption protocols guarantees the safeguarding of data during transmission, preserving both its integrity and confidentiality.

Latency

In the context of M2M communication, latency refers to the time interval between the transmission of data from a source device to a destination device and the subsequent reception of that data. Table 8 provides a comprehensive overview of the latency outcomes in the experimental results.

Figure 12 provides a visual representation of the latency comparison between the proposed method and existing approaches in M2M communication. The latency measurements reveal that the proposed method exhibits a lower latency of 1.09 s, as opposed to 1.65 s for EDDC and 1.70 s for LSTM. This comparison underscores the superior performance of the proposed approach in terms of reduced latency. Reduced latency has significant implications for M2M systems, as it enhances the speed and efficiency of device interactions. Lower latency facilitates faster data.

Packet loss rate

The packet loss rate, a vital metric in M2M communication, quantifies the percentage of data packets that become lost within the network during transmission. This metric serves as a critical indicator of the reliability and quality of the communication link. Monitoring and minimizing packet loss are paramount to ensure uninterrupted data transmission and maintain the dependability of M2M systems. A low packet loss rate signifies a robust and efficient communication link, contributing to the overall effectiveness and performance of M2M networks.

Figure 13 and Table 9 present the results related to the packet loss rate. When comparing the proposed method with existing approaches, it is evident that the proposed method exhibits a considerably lower packet loss rate. Specifically, the proposed method achieves an impressive packet loss rate of 8.8 bps, whereas EDDC records 10.1 bps, and GRADE records 10.6 bps.

A reduced packet loss rate means that a significant portion of data packets successfully reach their intended destination without experiencing loss or corruption during transit. This is of utmost importance in M2M systems, where the integrity of critical instructions and real-time data transfers must be preserved. By mitigating the likelihood of delays, inconsistent data, and potential interruptions within interconnected systems, a low packet loss rate contributes significantly to enhancing the overall performance of M2M communication.