# 边特征时空注意力模型

# Edge-Based Spatio-Temporal Attention Model

## 1. 输入输出 \| Input & Output

输入：\
Input:

X ∈ R\^(T × E × F)

输出：\
Output:

R_hat ∈ \[0,1\]

------------------------------------------------------------------------

## 2. 模型结构示意 \| Model Architecture

![Model Flow](figure_model_flow.png)

------------------------------------------------------------------------

## 3. 核心思想 \| Core Idea

时间注意力：关注关键时间步\
Temporal attention focuses on critical time steps

空间注意力：关注关键边\
Spatial attention focuses on critical edges


02_Model_Bilingual

# 多层网络可靠性数据生成

# Multilayer Network Reliability -- Data Generation



## 1. 问题定义 \| Problem Definition

构建一个三层有向网络。\
Construct a three-layer directed network.

- 每层包含若干节点（nodes数量每层随机）
- 每层内有随机连接边（intra_edges数量层内随机）
- 层间有跨层连接边（1层可与2或3层连接、2层只能与3层连接，edges数量层间随机）
- 层间节点假设绝对可靠（edges层间P=1）
- 层内边为随机容量变量（demands层内随机）
- 层间边为随机容量变量（demands层间随机）

-   节点完全可靠 \| Nodes are perfectly reliable
-   边容量随机 \| Edge capacities are stochastic

可靠性定义：\
Reliability is defined as:

R = P(max_flow ≥ Demand)

目标：
> 计算该网络在给定Demand下的可靠性
------------------------------------------------------------------------

## 2. 网络结构示意 \| Network Structure

![Multilayer Network.jpg](/static/img/b6318b2fedc1e1bac33b1aa66de68ca4.d41b11edba27103e6d9cfe3f34fea692.webp)

------------------------------------------------------------------------

## 3.随机边容量模型

每条边容量：

$$
 C_e \in ｛1,2,3,4｝
$$

概率分布：

$$
P(C_e = k) = p_k
$$
例如：

```python
capacity_values = [1, 2, 3, 4]
probabilities = [0.78, 0.10, 0.07, 0.05]
```
## 3. Python 数据生成程序 \| Python Implementation

``` python
import random
import numpy as np
import pandas as pd


# ===============================
# 三层随机图网络数据生成器
# ===============================
class ThreeLayerGraphGenerator:

    def __init__(self):

        # 每一层节点数量的随机范围
        self.layer1_range = (5,15)
        self.layer2_range = (8,19)
        self.layer3_range = (6,22)


    # --------------------------------
    # 生成三层节点
    # --------------------------------
    def generate_nodes(self):

        # 随机生成每层节点数量
        n1 = random.randint(*self.layer1_range)
        n2 = random.randint(*self.layer2_range)
        n3 = random.randint(*self.layer3_range)

        # 创建节点名称
        layer1 = [f"L1N{i}" for i in range(n1)]
        layer2 = [f"L2N{i}" for i in range(n2)]
        layer3 = [f"L3N{i}" for i in range(n3)]

        return layer1, layer2, layer3


    # --------------------------------
    # 生成概率并归一化
    # --------------------------------
    def generate_probabilities(self, num_edges):

        # 随机生成一组数
        probs = np.random.rand(num_edges)

        # 概率归一化，使概率之和 = 1
        probs = probs / probs.sum()

        return probs

    # =====================================
    # >>> MODIFIED
    # 生成层间边（概率固定为1）
    # =====================================
    def generate_edges(self, layerA, layerB):

        edge_list = []

        for a in layerA:
            for b in layerB:
                edge_list.append({
                    "from_node": a,
                    "to_node": b,
                    "probability": 1  # 跨层连接完全可靠
                })

        return edge_list

    # =====================================
    # >>> NEW
    # 生成层内边（概率随机，总和=1）
    # =====================================
    def generate_intra_layer_edges(self, layer_nodes):

        edges = []

        for i in layer_nodes:
            for j in layer_nodes:

                if i != j:
                    edges.append((i, j))

        # 生成概率
        probs = np.random.rand(len(edges))

        # 归一化
        probs = probs / probs.sum()

        edge_list = []

        for idx, e in enumerate(edges):
            edge_list.append({
                "from_node": e[0],
                "to_node": e[1],
                "probability": float(probs[idx])
            })

        return edge_list

    # =========================================
    # >>> MODIFIED
    # 生成节点之间的单向 Demand
    # 包括层间的Demand和层内节点的Demand
    # =========================================
    def generate_demands(self, layer1, layer2, layer3):

        demands = []
        a = 200
        b = 1000

        # =========================
        # >>> NEW
        # Layer1 内部 Demand
        # =========================
        for i in layer1:
            for j in layer1:

                if i != j:

                    if random.random() < 0.2:
                        demands.append({
                            "from_node": i,
                            "to_node": j,
                            "demand": random.randint(a,b)
                        })

        # =========================
        # >>> NEW
        # Layer2 内部 Demand
        # =========================
        for i in layer2:
            for j in layer2:

                if i != j:

                    if random.random() < 0.2:
                        demands.append({
                            "from_node": i,
                            "to_node": j,
                            "demand": random.randint(a,b)
                        })

        # =========================
        # >>> NEW
        # Layer3 内部 Demand
        # =========================
        for i in layer3:
            for j in layer3:

                if i != j:

                    if random.random() < 0.2:
                        demands.append({
                            "from_node": i,
                            "to_node": j,
                            "demand": random.randint(a,b)
                        })

        # =========================
        # Layer1 → Layer2
        # =========================
        for n1 in layer1:
            for n2 in layer2:

                if random.random() < 0.3:
                    demands.append({
                        "from_node": n1,
                        "to_node": n2,
                        "demand": random.randint(a,b)
                    })

        # =========================
        # Layer1 → Layer3
        # =========================
        for n1 in layer1:
            for n3 in layer3:

                if random.random() < 0.3:
                    demands.append({
                        "from_node": n1,
                        "to_node": n3,
                        "demand": random.randint(a,b)
                    })

        # =========================
        # Layer2 → Layer3
        # =========================
        for n2 in layer2:
            for n3 in layer3:

                if random.random() < 0.3:
                    demands.append({
                        "from_node": n2,
                        "to_node": n3,
                        "demand": random.randint(a,b)
                    })

        return demands


    # --------------------------------
    # 生成完整网络
    # --------------------------------
    def generate_graph(self) -> object:

        # 生成节点
        layer1, layer2, layer3 = self.generate_nodes()

        # 生成层间边
        edges12 = self.generate_edges(layer1, layer2)
        edges13 = self.generate_edges(layer1, layer3)
        edges23 = self.generate_edges(layer2, layer3)

        # 层内边（概率随机）
        intra_edges1 = self.generate_intra_layer_edges(layer1)
        intra_edges2 = self.generate_intra_layer_edges(layer2)
        intra_edges3 = self.generate_intra_layer_edges(layer3)

        # 生成需求
        demands = self.generate_demands(layer1, layer2, layer3)

        return layer1, layer2, layer3, edges12, edges13, edges23, intra_edges1, intra_edges2, intra_edges3, demands


    # --------------------------------
    # 保存为表格文件
    # --------------------------------
    def save_to_csv(self, layer1, layer2, layer3, edges12, edges13, edges23, intra_edges1, intra_edges2, intra_edges3, demands):

        # 节点表
        nodes = []

        for n in layer1:
            nodes.append({"node": n, "layer": "Layer1"})

        for n in layer2:
            nodes.append({"node": n, "layer": "Layer2"})

        for n in layer3:
            nodes.append({"node": n, "layer": "Layer3"})

        df_nodes = pd.DataFrame(nodes)

        df_edges12 = pd.DataFrame(edges12)
        df_edges13 = pd.DataFrame(edges13)
        df_edges23 = pd.DataFrame(edges23)

        # >>> NEW
        df_intra1 = pd.DataFrame(intra_edges1)
        df_intra2 = pd.DataFrame(intra_edges2)
        df_intra3 = pd.DataFrame(intra_edges3)


        # demand表
        df_demands = pd.DataFrame(demands)

        # 保存CSV
        df_nodes.to_csv("layer_nodes.csv", index=False)
        df_edges12.to_csv("edges_L1_L2.csv", index=False)
        df_edges13.to_csv("edges_L1_L3.csv", index=False)
        df_edges23.to_csv("edges_L2_L3.csv", index=False)

        # >>> new
        df_intra1.to_csv("edges_L1.csv", index=False)
        df_intra2.to_csv("edges_L2.csv", index=False)
        df_intra3.to_csv("edges_L3.csv", index=False)

        df_demands.to_csv("demands.csv", index=False)

        print("数据已保存为CSV文件")


# =====================================
# 主程序
# =====================================
if __name__ == "__main__":

    generator = ThreeLayerGraphGenerator()

    layer1, layer2, layer3, edges12, edges13, edges23, intra_edges1, intra_edges2, intra_edges3, demands = generator.generate_graph()

    generator.save_to_csv(layer1, layer2, layer3, edges12, edges13, edges23, intra_edges1, intra_edges2, intra_edges3, demands)
```