$$\rightleftharpoonup{xx}$$
$$\longleftharp{xx}$$,
$$\longrightharp{xx}$$,
Fluxo de trabalho de transmissão de dados e processamento de pacotes
Inicialização do nó: Cada nó começa com informações completas sobre a topologia da rede, sua capacidade máxima de energia e um agente SAC pré-treinado pronto para tomada de decisão. O módulo de codificação de rede ativa e prepara operações de combinação de pacotes.
Processo de codificação de pacotes: Quando a transmissão começa, os nós de origem coletam múltiplos pacotes de dados dos sensores. O módulo de codificação de rede combina esses pacotes em menos pacotes codificados usando operações matemáticas eficientes, reduzindo significativamente o número total de transmissões necessárias.
Execução da decisão de roteamento do SAC: O agente SAC analisa o estado atual da rede, incluindo níveis de energia dos vizinhos, qualidade do link, condições de tráfego e distância de destino. Ela seleciona o vizinho ideal do próximo salto com base em sua política apropriada, priorizando eficiência energética e confiabilidade.
Encaminhamento de pacotes multi-hop: Pacotes codificados viajam pelo caminho selecionado. Nós intermediários decidem se combinam pacotes ou os encaminham diretamente, com base no status atual do buffer e nos níveis de energia remanescentes.
Cálculo e armazenamento de recompensas: Após cada transmissão, o sistema calcula uma pontuação de recompensa baseada no sucesso da entrega, energia utilizada, atraso na transmissão e quedas de pacotes. Essas informações de recompensa são armazenadas para que o agente do SAC aprenda.
Atualização de aprendizado contínuo: O agente do SAC revisa regularmente as experiências armazenadas e atualiza sua estratégia de tomada de decisão para melhorar a escolha de rotas energeticamente eficientes, mantendo um alto desempenho de entrega.
Arquitetura do sistema
Um nó típico opera da seguinte forma: ele detecta e coleta dados, codifica-os usando codificação de rede e então encaminha o pacote codificado por um caminho de roteamento selecionado pelo agente SAC. O agente SAC avalia o estado do nó, incluindo energia remanescente, status do buffer e qualidade do link, para decidir o próximo salto ótimo. Esse processo é dinâmico e evolui com a experiência conforme as condições da rede mudam. A Figura 1 ilustrará esse fluxo de dados e a interação entre os componentes.
Equação de codificação de rede
A codificação de rede é aplicada nos nós intermediários da seguinte forma:

Onde Ci é o pacote codificado, αij é o coeficiente de codificação (aprendido via SAC), e Pj são os pacotes originais. Isso permite que a rede reduza o número de transmissões e melhore a confiabilidade.
Função objetivo SAC
O agente SAC otimiza a política usando o seguinte objetivo regularizado por entropia:

Onde r(s t, a t) é a recompensa, α é um parâmetro de troca para a exploração, e H é o termo de entropia.
Modelo de consumo de energia
Para simular o uso realista de energia, é utilizado o seguinte modelo:

Onde: E elec- é a energia por bit para operar o transmissor/receptor, - k é o tamanho dos dados em bits, -
é a energia necessária pelo amplificador do transmissor, - é a distância entre nós, -d é o expoente de perda de caminho.
Métricas de avaliação
As seguintes métricas de desempenho foram usadas nas simulações deste estudo:
Razão de entrega de pacotes (PDR):

Rendimento:

Vida útil da rede: Definido como a duração até que 50% dos nós da rede esgotem sua energia.
Eficiência energética:

Pseudocódigo
Inicialização de nós de rede IoT
Essa função configura todos os nós IoT na rede antes que o sistema comece a operar. Cada nó recebe energia máxima, um buffer vazio para armazenar pacotes, um estado representando seu ambiente local, um agente SAC para aprender decisões ótimas e um módulo NC que permite a codificação inteligente de dados.
def initialize_nodes(rede):
Para nó na rede:
node.energia = MAX_ENERGY
node.buffer = []
nó.estado = sense_environment(nó)
node.agent = initialize_sac_agent()
node.nc_module = activate_network_coding()
Geração de pacotes e codificação de rede
Essa função é responsável por coletar dados do sensor do nó de origem, codifica-los usando um método linear ou baseado em XOR, e prepará-los para transmissão. Ele reduz a sobrecarga de comunicação ao agrupar múltiplos pacotes em um pacote codificado, pronto para ser encaminhado pela rede.
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)
Def network_code(pacotes):
retorno linear_combination(pacotes)
Decisão de roteamento baseada em SAC
Aqui, o nó atual usa seu agente SAC para analisar o estado da rede e selecionar o vizinho mais eficiente em energia e confiável para encaminhar o pacote. A decisão baseia-se em políticas acadêmicas e nas condições ambientais atuais, como qualidade do link ou energia residual.
Definitivamente select_next_hop(current_node):
current_state = observe_network_state(current_node)
Ação = sac_agent_policy(current_node.agente, current_state)
next_hop = map_action_to_neighbor(ação)
retorno next_hop
Transmissão de pacotes e loop de realimentação
Essa função gerencia a transmissão real de um pacote codificado. Após determinar o melhor próximo salto, o pacote é enviado se o link for válido. O sistema então calcula uma recompensa baseada no sucesso da transmissão e no uso de energia, que é usada para atualizar o modelo de aprendizado do agente SAC.
Def transmit_packet(current_node, pacote):
next_hop = select_next_hop(current_node)
se is_link_valid(current_node, next_hop):
enviar (pacote, next_hop)
recompensa = compute_reward(current_node, pacote)
update_sac_agent(current_node, recompensa)
Caso contrário:
recompute_next_hop(current_node)
Atualização do agente SAC (fase de aprendizado)
Uma vez que um pacote é transmitido, essa função atualiza o agente SAC. Ele registra a mudança de estado, armazena a experiência na memória e, se experiência suficiente for coletada, utiliza um lote de amostra para melhorar a estratégia de tomada de decisão do agente. Isso ajuda o nó a se adaptar às mudanças da rede ao longo do tempo.
Def update_sac_agent(Nó, Recompensa):
new_state = observe_network_state(nó)
store_transition(node.agent.memory, node.state, node.action, reward, new_state)
se enough_experience(node.agent.memory):
batch = sample_batch(node.agent.memory)
node.agent = optimize_sac(node.agent, batch)
nó.estado = new_state
Decodificação no receptor
No destino, essa função recebe todos os pacotes codificados recebidos e os decodifica de volta para os dados originais usando métodos como a Eliminação Gaussana. Os dados recuperados são então passados para a camada ou processo de aplicação apropriado.
Def decode_packet(destination_node):
received_packets = destination_node.buffer
original_data = decodificar(received_packets)
deliver_data(original_data)
Decodificação DEF (pacotes):
retorno gaussian_elimination(pacotes)
Monitoramento de energia e lógica do sono de nós
Essa função acompanha os níveis de energia de cada nó e determina se um nó deve continuar operando ou mudar para o modo de suspensão para conservar energia. Se a energia for suficiente, o nó deduz os custos relacionados à transmissão; se não, ele desliga temporariamente para estender a vida útil da rede.
Def monitor_energy(node):
se node.energy < THRESHOLD:
put_node_to_sleep(nó)
Else: node.energy -= transmission_cost()