$$\rightleftharpoonup{xx}$$
$$\longleftharp{xx}$$,
$$\longrightharp{xx}$$,
Flux de travail de transmission de données et traitement des paquets
Initialisation du nœud : Chaque nœud commence avec des informations complètes sur la topologie du réseau, sa capacité énergétique maximale et un agent SAC pré-entraîné prêt à prendre des décisions. Le module de codage réseau active et prépare les opérations de combinaison de paquets.
Processus d’encodage de paquets : Lorsque la transmission commence, les nœuds sources collectent plusieurs paquets de données provenant des capteurs. Le module de codage réseau combine ces paquets en moins de paquets codés grâce à des opérations mathématiques efficaces, réduisant significativement le nombre total de transmissions nécessaires.
Exécution de la décision de routage SAC : L’agent SAC analyse l’état actuel du réseau, y compris les niveaux d’énergie des voisins, la qualité du lien, les conditions de trafic et la distance de destination. Il sélectionne le voisin optimal du prochain saut en fonction de sa politique apprise, en privilégiant l’efficacité énergétique et la fiabilité.
Transfert de paquets multi-sauts : Les paquets codés parcourent le chemin sélectionné. Les nœuds intermédiaires décident s’ils doivent combiner davantage les paquets ou les transmettre directement, en fonction de leur statut actuel de tampon et de leurs niveaux d’énergie restants.
Calcul et stockage de la récompense : Après chaque transmission, le système calcule un score de récompense basé sur le succès de la livraison, l’énergie utilisée, le délai de transmission et les chutes de paquets. Ces informations sur la récompense sont stockées pour que l’agent SAC puisse en apprendre.
Mise à jour de l’apprentissage continu : L’agent SAC examine régulièrement les expériences stockées et met à jour sa stratégie décisionnelle afin de mieux choisir des itinéraires économes en énergie tout en maintenant une performance de livraison élevée.
Architecture système
Un nœud typique fonctionne comme suit : il détecte et collecte des données, les encode en codage réseau, puis transmet le paquet encodé via un chemin de routage sélectionné par l’agent SAC. L’agent SAC évalue l’état du nœud, y compris l’énergie restante, l’état du tampon et la qualité du lien, afin de décider du prochain saut optimal. Ce processus est dynamique et évolue au fil de l’expérience à mesure que les conditions du réseau évoluent. La figure 1 illustrera ce flux de données et l’interaction entre les composants.
Équation de codage de réseau
Le codage réseau est appliqué aux nœuds intermédiaires comme suit :

Où Ci est le paquet encodé, αij est le coefficient de codage (appris via SAC), et Pj sont les paquets originaux. Cela permet au réseau de réduire le nombre de transmissions et d’améliorer la fiabilité.
Fonction objectif SAC
L’agent SAC optimise la politique en utilisant l’objectif régulier entropie suivant :

Où r(s t, a t) est la récompense, α est un paramètre de compromis pour l’exploration, et H est le terme d’entropie.
Modèle de consommation d’énergie
Pour simuler une consommation d’énergie réaliste, le modèle suivant est utilisé :

Où : Eelec- est l’énergie par bit pour faire fonctionner l’émetteur/récepteur, - k est la taille des données en bits, -
est l’énergie requise par l’amplificateur émetteur, - est la distance entre les nœuds, -d est l’exposant de perte de chemin.
Indicateurs d’évaluation
Les indicateurs de performance suivants ont été utilisés dans les simulations de cette étude :
Ratio de livraison des paquets (PDR) :

Débit :

Durée de vie du réseau : Définie comme la durée jusqu’à ce que 50 % des nœuds réseau épuisent leur énergie.
Efficacité énergétique :

Pseudocode
Initialisation des nœuds réseau IoT
Cette fonction configure tous les nœuds IoT du réseau avant que le système ne commence à fonctionner. Chaque nœud se voit attribuer une énergie maximale, un tampon vide pour stocker les paquets, un état représentant son environnement local, un agent SAC pour apprendre les décisions optimales, et un module NC permettant un codage intelligent des données.
Défense initialize_nodes (réseau) :
pour le nœud dans le réseau :
nœud.énergie = MAX_ENERGY
nœud.tampon = []
nœud.état = sense_environment(nœud)
node.agent = initialize_sac_agent()
node.nc_module = activate_network_coding()
Génération de paquets et codage réseau
Cette fonction est responsable de la collecte des données des capteurs depuis le nœud source, de leur encodage à l’aide d’une méthode de codage réseau linéaire ou basée sur XOR, et de leur préparation pour la transmission. Il réduit la surcharge de communication en regroupant plusieurs paquets en un seul paquet codé, prêt à être transmis via le réseau.
Def generate_and_code_packets(source_node) :
data_packets = collect_data(source_node)
coded_packet = network_code(data_packets)
queue_transmission(source_node, coded_packet)
Définitivement network_code(paquets) :
retour linear_combination(paquets)
Décision de routage basée sur le SAC
Ici, le nœud courant utilise son agent SAC pour analyser l’état du réseau et sélectionner le voisin le plus économe en énergie et fiable vers lequel transférer le paquet. La décision repose sur des politiques avérées et des conditions environnementales actuelles, comme la qualité des liens ou l’énergie résiduelle.
définitivement select_next_hop(current_node) :
current_state = observe_network_state(current_node)
action = sac_agent_policy(current_node.agent, current_state)
next_hop = map_action_to_neighbor(action)
retour next_hop
Transmission de paquets et boucle de rétroaction
Cette fonction gère la transmission effective d’un paquet codé. Après avoir déterminé le meilleur saut suivant, le paquet est envoyé si le lien est valide. Le système calcule ensuite une récompense basée sur le succès de la transmission et la consommation d’énergie, qui sert à mettre à jour le modèle d’apprentissage de l’agent SAC.
Définitivement transmit_packet(current_node, paquet) :
next_hop = select_next_hop(current_node)
Si is_link_valid(current_node, next_hop) :
envoyer (paquet, next_hop)
récompense = compute_reward(current_node, paquet)
update_sac_agent(current_node, récompense)
Sinon :
recompute_next_hop(current_node)
Mise à jour de l’agent SAC (phase d’apprentissage)
Une fois qu’un paquet est transmis, cette fonction met à jour l’agent SAC. Il enregistre le changement d’état, stocke l’expérience en mémoire, et si suffisamment d’expérience est accumulée, il utilise un lot d’échantillons pour améliorer la stratégie décisionnelle de l’agent. Cela aide le nœud à s’adapter aux changements du réseau au fil du temps.
Définitivement update_sac_agent(nœud, récompense) :
new_state = observe_network_state(nœud)
store_transition(node.agent.memory, node.state, node.action, récompense, new_state)
if enough_experience(node.agent.memory) :
batch = sample_batch(node.agent.memory)
node.agent = optimize_sac(node.agent, batch)
node.state = new_state
Décodage au récepteur
À destination, cette fonction reçoit tous les paquets codés reçus et les décode dans les données originales en utilisant des méthodes comme l’élimination gaussienne. Les données récupérées sont ensuite transmises à la couche ou au processus applicatif approprié.
Définitivement decode_packet(destination_node) :
received_packets = destination_node.tampon
original_data = décoder (received_packets)
deliver_data(original_data)
Décodage DEF (paquets) :
retour gaussian_elimination(paquets)
Surveillance de l’énergie et logique du sommeil des nœuds
Cette fonction suit les niveaux d’énergie de chaque nœud et détermine si un nœud doit continuer à fonctionner ou passer en mode veille pour économiser de l’énergie. Si l’énergie est suffisante, le nœud déduit les coûts liés à la transmission ; Sinon, il s’arrête temporairement pour prolonger la durée de vie globale du réseau.
Def monitor_energy(nœud) :
si node.energy < SEUIL :
put_node_to_sleep(nœud)
sinon : node.energy -= transmission_cost()