如何在TensorFlow中运行多模型？附自研神经网络模型及训练代码

嘿，我来帮你梳理下在TensorFlow里运行多个独立模型的几种常用实现方式，顺便先提个小细节：你当前的训练循环里，每次epoch都重新初始化全局变量，这会导致模型参数被反复重置，根本学不到东西，要把init_op的定义和执行放在循环外面哦！

下面分三种方案来实现多模型运行：

方案1：使用独立的Graph对象隔离模型 #

每个模型创建自己的tf.Graph对象，然后绑定对应的Session来运行，完全隔离不同模型的计算图和变量，适合需要彻底隔离的场景。

代码示例 #

import tensorflow as tf

# 定义通用的模型构建函数
def build_model(feature_count, target_count):
    x = tf.placeholder(tf.float32, [None, feature_count])
    y_ = tf.placeholder(tf.float32, [None, target_count])
    W = tf.Variable(tf.zeros([feature_count, target_count]))
    b = tf.Variable(tf.zeros([target_count]))
    y = tf.nn.softmax(tf.matmul(x, W) + b)
    cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
    correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
    return x, y_, train_op, accuracy

# 创建第一个模型的Graph和Session
graph1 = tf.Graph()
with graph1.as_default():
    x1, y1_, train_op1, acc1 = build_model(feature_count=10, target_count=2)
    init1 = tf.global_variables_initializer()

sess1 = tf.Session(graph=graph1)
sess1.run(init1)

# 创建第二个模型的Graph和Session
graph2 = tf.Graph()
with graph2.as_default():
    x2, y2_, train_op2, acc2 = build_model(feature_count=10, target_count=2)
    init2 = tf.global_variables_initializer()

sess2 = tf.Session(graph=graph2)
sess2.run(init2)

# 分别训练两个模型
training_epochs = 10
for epoch in range(training_epochs):
    # 训练模型1
    curr_data1, curr_target1 = sess1.run([data_batch, target_batch])
    sess1.run(train_op1, feed_dict={x1: curr_data1, y1_: curr_target1})
    # 训练模型2
    curr_data2, curr_target2 = sess2.run([data_batch, target_batch])
    sess2.run(train_op2, feed_dict={x2: curr_data2, y2_: curr_target2})

方案2：使用命名空间（Variable Scope）隔离变量 #

在同一个Graph里，用tf.variable_scope给每个模型的变量添加独特前缀，避免变量名冲突，适合需要共享Session资源的轻量级多模型场景。

代码示例 #

import tensorflow as tf

def build_model_with_scope(scope_name, feature_count, target_count):
    with tf.variable_scope(scope_name):
        x = tf.placeholder(tf.float32, [None, feature_count])
        y_ = tf.placeholder(tf.float32, [None, target_count])
        W = tf.Variable(tf.zeros([feature_count, target_count]))
        b = tf.Variable(tf.zeros([target_count]))
        y = tf.nn.softmax(tf.matmul(x, W) + b)
        cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
        correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
        train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
        return x, y_, train_op, accuracy

# 在同一个Graph里创建两个模型
x1, y1_, train_op1, acc1 = build_model_with_scope("model1", feature_count=10, target_count=2)
x2, y2_, train_op2, acc2 = build_model_with_scope("model2", feature_count=10, target_count=2)

# 初始化所有变量
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    training_epochs = 10
    for epoch in range(training_epochs):
        # 训练模型1
        curr_data1, curr_target1 = sess.run([data_batch, target_batch])
        sess.run(train_op1, feed_dict={x1: curr_data1, y1_: curr_target1})
        # 训练模型2
        curr_data2, curr_target2 = sess.run([data_batch, target_batch])
        sess.run(train_op2, feed_dict={x2: curr_data2, y2_: curr_target2})

方案3：封装为模型类（面向对象方式） #

把模型的变量、计算逻辑封装成类，每个类实例对应一个独立模型，代码结构最清晰，适合复杂场景下的模型管理和扩展。

代码示例 #

import tensorflow as tf

class SoftmaxModel:
    def __init__(self, feature_count, target_count, learning_rate=0.01):
        self.feature_count = feature_count
        self.target_count = target_count
        self.learning_rate = learning_rate
        self._build_graph()
    
    def _build_graph(self):
        self.x = tf.placeholder(tf.float32, [None, self.feature_count])
        self.y_ = tf.placeholder(tf.float32, [None, self.target_count])
        self.W = tf.Variable(tf.zeros([self.feature_count, self.target_count]))
        self.b = tf.Variable(tf.zeros([self.target_count]))
        self.y = tf.nn.softmax(tf.matmul(self.x, self.W) + self.b)
        self.cross_entropy = tf.reduce_mean(-tf.reduce_sum(self.y_ * tf.log(self.y), reduction_indices=[1]))
        self.correct_prediction = tf.equal(tf.argmax(self.y,1), tf.argmax(self.y_,1))
        self.accuracy = tf.reduce_mean(tf.cast(self.correct_prediction, tf.float32))
        self.train_op = tf.train.GradientDescentOptimizer(self.learning_rate).minimize(self.cross_entropy)

# 创建两个模型实例
model1 = SoftmaxModel(feature_count=10, target_count=2)
model2 = SoftmaxModel(feature_count=10, target_count=2)

# 初始化所有变量
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    training_epochs = 10
    for epoch in range(training_epochs):
        # 训练模型1
        curr_data1, curr_target1 = sess.run([data_batch, target_batch])
        sess.run(model1.train_op, feed_dict={model1.x: curr_data1, model1.y_: curr_target1})
        # 训练模型2
        curr_data2, curr_target2 = sess.run([data_batch, target_batch])
        sess.run(model2.train_op, feed_dict={model2.x: curr_data2, model2.y_: curr_target2})

以上三种方案各有优劣：

• 独立Graph方案隔离性最强，但资源占用略高；
• 命名空间方案适合轻量级多模型，共享Session资源；
• 类封装方案代码结构最清晰，适合复杂场景下的模型管理。

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