基于自定义链接数组构建TensorFlow计算图（神经网络结构）求助

嘿，刚上手TensorFlow的话，用自定义的Link数组来构建计算图确实需要先理清楚逻辑，我给你拆解一下实现思路，再结合伪代码和Python代码来演示~

首先，咱们得先明确几个核心点：你的Link数组应该包含源节点ID、目标节点ID、权重这三个信息对吧？每个目标节点的输出，就是所有指向它的源节点输出和对应权重的点积（本质就是加权求和）。接下来一步步来：

伪代码思路 #

先把整体逻辑用伪代码梳理清楚，这样你能更清晰地理解流程：

# 定义Link结构，存储连接关系和权重
结构体 Link:
    source_id: 源节点ID
    target_id: 目标节点ID
    weight: 连接权重

# 第一步：预处理Link数组，按目标节点分组输入
创建字典 node_inputs，键是目标节点ID，值是该节点的所有输入连接列表
遍历每个Link in Link数组:
    如果目标节点ID不在node_inputs中:
        初始化node_inputs[目标节点ID]为空列表
    将当前Link添加到node_inputs[目标节点ID]中

# 第二步：创建TensorFlow节点张量
创建字典 tf_nodes，存储每个节点对应的tf.Tensor
收集所有节点ID（包括输入节点和中间/输出节点）
遍历每个节点ID:
    如果节点ID没有输入（不在node_inputs的键中，说明是输入节点）:
        tf_nodes[节点ID] = 占位符/输入张量（用于接收外部输入）
    否则:
        从tf_nodes中取出所有源节点的张量
        取出对应连接的权重
        计算每个源节点张量与权重的乘积
        将所有乘积相加，得到当前节点的输出张量
        将该输出张量存入tf_nodes[节点ID]

# 第三步：运行计算（根据TensorFlow版本选择会话或函数调用）
传入输入节点的数值，计算目标节点的输出结果

Python代码实现（TensorFlow 2.x 版本） #

TF2.x默认是Eager Execution模式，用Keras的Functional API来构建模型会更直观，下面是完整示例：

import tensorflow as tf
from dataclasses import dataclass

# 用dataclass定义Link结构，简洁清晰
@dataclass
class Link:
    source_id: int
    target_id: int
    weight: float

# 示例Link数组：构建一个简单的计算图
# 输入节点0、1 → 节点2（接收0和1的输入，权重0.5、0.3）→ 节点3（接收2的输入，权重0.8）
link_array = [
    Link(source_id=0, target_id=2, weight=0.5),
    Link(source_id=1, target_id=2, weight=0.3),
    Link(source_id=2, target_id=3, weight=0.8)
]

# 1. 预处理：按目标节点分组输入连接
node_inputs = {}
for link in link_array:
    if link.target_id not in node_inputs:
        node_inputs[link.target_id] = []
    node_inputs[link.target_id].append(link)

# 2. 收集所有节点ID（确保不遗漏输入节点）
all_node_ids = set()
for link in link_array:
    all_node_ids.add(link.source_id)
    all_node_ids.add(link.target_id)
all_node_ids = sorted(all_node_ids)

# 3. 创建TensorFlow节点张量
tf_nodes = {}
for node_id in all_node_ids:
    if node_id not in node_inputs:
        # 输入节点：用tf.keras.Input创建输入张量，shape根据你的数据调整
        tf_nodes[node_id] = tf.keras.Input(shape=(None,), name=f"input_{node_id}")
    else:
        # 获取所有源节点的张量和对应权重
        source_tensors = [tf_nodes[link.source_id] for link in node_inputs[node_id]]
        weights = [link.weight for link in node_inputs[node_id]]
        
        # 计算加权求和（逐元素相乘后累加，等价于点积）
        weighted_terms = [tf.multiply(tensor, weight) for tensor, weight in zip(source_tensors, weights)]
        node_output = tf.add_n(weighted_terms, name=f"node_{node_id}_output")
        
        tf_nodes[node_id] = node_output

# 4. 构建模型并测试
# 以输入节点0、1为输入，节点3为输出构建模型
model = tf.keras.Model(inputs=[tf_nodes[0], tf_nodes[1]], outputs=tf_nodes[3])

# 测试输入：输入0的值是[1.0, 2.0]，输入1的值是[3.0, 4.0]
input_0 = tf.convert_to_tensor([1.0, 2.0])
input_1 = tf.convert_to_tensor([3.0, 4.0])

# 计算输出
output = model([input_0, input_1])
print(f"节点3的输出结果: {output.numpy()}")
# 预期输出：[1.12, 1.76] → 计算过程：节点2 = (1*0.5+3*0.3)=1.4，(2*0.5+4*0.3)=2.2；节点3=1.4*0.8=1.12，2.2*0.8=1.76

补充：TensorFlow 1.x 版本实现（如果还在使用旧版本） #

TF1.x需要手动管理会话，代码逻辑类似，但需要禁用Eager Execution：

import tensorflow as tf
from dataclasses import dataclass

# 禁用Eager Execution，适配TF1.x
tf.disable_eager_execution()

@dataclass
class Link:
    source_id: int
    target_id: int
    weight: float

link_array = [
    Link(0, 2, 0.5),
    Link(1, 2, 0.3),
    Link(2, 3, 0.8)
]

# 预处理分组
node_inputs = {}
for link in link_array:
    if link.target_id not in node_inputs:
        node_inputs[link.target_id] = []
    node_inputs[link.target_id].append(link)

all_node_ids = sorted({link.source_id for link in link_array} | {link.target_id for link in link_array})

# 创建TF节点
tf_nodes = {}
for node_id in all_node_ids:
    if node_id not in node_inputs:
        tf_nodes[node_id] = tf.placeholder(tf.float32, shape=[None], name=f"input_{node_id}")
    else:
        source_tensors = [tf_nodes[link.source_id] for link in node_inputs[node_id]]
        weights = [link.weight for link in node_inputs[node_id]]
        weighted_terms = [tf.multiply(t, w) for t, w in zip(source_tensors, weights)]
        node_output = tf.add_n(weighted_terms, name=f"node_{node_id}_output")
        tf_nodes[node_id] = node_output

# 运行会话计算
with tf.Session() as sess:
    feed_dict = {
        tf_nodes[0]: [1.0, 2.0],
        tf_nodes[1]: [3.0, 4.0]
    }
    output = sess.run(tf_nodes[3], feed_dict=feed_dict)
    print(f"节点3的输出结果: {output}")

关键说明 #

• 预处理Link数组的目的是把每个目标节点的所有输入连接整理到一起，这样构建计算图时不用反复遍历整个数组。
• tf.add_n相比逐个用tf.add更高效，能直接对多个张量求和。
• 如果你的节点输出是高维张量（比如二维特征），这个逻辑完全适用，因为tf.multiply是逐元素相乘，tf.add_n是逐元素累加，本质就是张量的点积运算。

内容的提问来源于stack exchange，提问作者5ar