Tensorflow服务器：我不想为每个会话初始化全局变量

Question

下面的Github链接包含从进程调用TF模型问题的可能解决方案。它们包括急切执行和专用服务器进程，通过http请求提供TF模型预测。我想知道，与每次初始化全局变量并调用tf.train.Server相比，定制服务器和请求是否能赢得任何时间，但这似乎是一种更优雅的方式。在

我将调查内存泄漏，如果它消失了，关闭这个问题。在

编辑：添加了问题的简单可复制示例：

https://github.com/hcl14/Tensorflow-server-launched-from-child-process

---

后台：我正在运行Tensorflow服务器，并从“分叉”进程连接到它。动态地创建（和销毁）进程对我来说是非常重要的—我将高负载的部分代码移到了那里，因为有一个weird memory leak，Python探查器看不到它（线程不能解决这个问题）。因此，我希望进程快速初始化并立即开始工作。只有在进程被破坏时才会释放内存。在

在做实验的时候，我发现了一个解决方案：将加载的模型和图形保存到全局变量中，然后由子进程（默认使用“fork”模式）获取，然后调用服务器。在

问题：对我来说奇怪的是，在加载keras模型之后，我不能锁定我不希望修改的图形，而且每次在子进程中打开新会话时，我都需要运行tf.global_variables_initializer()。但是，在不创建任何会话的情况下在主流中运行虚拟运行可以正常工作。我知道在本例中，tensorflow使用默认会话，但是在模型运行之后，图上的所有变量都应该初始化，所以我希望新的会话能够与先前定义的图一起正常工作。在

因此，我认为修改模型会使Python对子进程进行大量pickle（“fork”模式），这会造成计算和内存开销。在

请原谅我有很多代码。我使用的模型是遗留的，对我来说是黑盒，所以我的问题可能与它有关。Tensorflow版本是1.2（我无法升级，模型不兼容），Python3.6.5。在

另外，也许我的解决方案效率低下，还有更好的解决方案，我将非常感谢你的建议。在

我的设置如下：

1.Tensorflow服务器在主进程中启动：

初始化服务器：

def start_tf_server():
    import tensorflow as tf
    cluster = tf.train.ClusterSpec({"local": [tf_server_address]})
    server = tf.train.Server(cluster, job_name="local", task_index=0)    
    server.join() # block process from exiting

主要工序：

^{pr2}$

2.init_interests_for_process()是一个模型初始值设定项，它加载我的旧模型并在全局变量中共享它。我做了一个虚拟模型传递，让图上的所有内容都初始化，然后想锁定这个图。但它不起作用：

def init_interests_for_process():
    # Prevent errors on my GPU and disable tensorflow 
    # complaining about CPU instructions
    import os
    os.environ["CUDA_VISIBLE_DEVICES"]= ""
    os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

    import tensorflow as tf

    from tensorflow.contrib.keras import models

    # create tensorflow graph
    graph = tf.get_default_graph()

    with graph.as_default():

        TOKENIZER = joblib.load(TOKENIZER_FILE)

        NN1_MODEL = models.load_model(NN1_MODEL_FILE)

        with open(NN1_CATEGORY_NAMES_FILE, 'r') as f:
            NN1_CATEGORY_NAMES = f.read().splitlines()

        NN2_MODEL = models.load_model(NN2_MODEL_FILE)

        with open(NN2_CATEGORY_NAMES_FILE, 'r') as f:
            NN2_CATEGORY_NAMES = f.read().splitlines()
        # global variable with all the data to be shared
        interests = {}

        interests["TOKENIZER"] = TOKENIZER
        interests["NN1_MODEL"] = NN1_MODEL
        interests["NN1_CATEGORY_NAMES"] = NN1_CATEGORY_NAMES
        interests["NN2_MODEL"] = NN2_MODEL
        interests["NN2_CATEGORY_NAMES"] = NN2_CATEGORY_NAMES
        interests['all_category_names'] = NN1_CATEGORY_NAMES + \
                                          NN2_CATEGORY_NAMES
        # Reconstruct a Python object from a file persisted with joblib.dump.
        interests["INTEREST_SETTINGS"] = joblib.load(INTEREST_SETTINGS_FILE)

        # dummy run to create graph
        x = tf.contrib.keras.preprocessing.sequence.pad_sequences(
                         TOKENIZER.texts_to_sequences("Dummy srting"),
                         maxlen=interests["INTEREST_SETTINGS"]["INPUT_LENGTH"]
                         )
        y1 = NN1_MODEL.predict(x)
        y2 = NN2_MODEL.predict(x)

        # PROBLEM: I want, but cannot lock graph, as child process 
        # wants to run its own tf.global_variables_initializer()
        # graph.finalize()

        interests["GRAPH"] = graph

        return interests

3.现在我生成进程（实际上，该进程是从另一个进程派生的-层次结构很复杂）：

def foo(q):
     result = call_function_which_uses_interests_model(some_data) 
     q.put(result)
     return # I've read it is essential for destroying local variables
q = Queue()
p = Process(target=foo,args=(q,))
p.start()
p.join()
result = q.get() # retrieve data

4.在这个过程中，我称之为模型：

# retrieve model from global variable
interests = global_vars.multiprocess_globals["interests"]

tokenizer = interests["TOKENIZER"]
nn1_model = interests["NN1_MODEL"]
nn1_category_names = interests["NN1_CATEGORY_NAMES"]
nn2_model = interests["NN2_MODEL"]
nn2_category_names = interests["NN2_CATEGORY_NAMES"]
input_length = interests["INTEREST_SETTINGS"]["INPUT_LENGTH"]

# retrieve graph
graph = interests["GRAPH"]

# open session for server
logger.debug('Trying tf server at ' + 'grpc://'+tf_server_address)
sess = tf.Session('grpc://'+tf_server_address, graph=graph)

# PROBLEM: and I need to run variables initializer:
sess.run(tf.global_variables_initializer())


tf.contrib.keras.backend.set_session(sess)

# finally, make a call to server:
with sess.as_default():        
    x = tf.contrib.keras.preprocessing.sequence.pad_sequences(
                            tokenizer.texts_to_sequences(input_str),
                            maxlen=input_length)
    y1 = nn1_model.predict(x)
    y2 = nn2_model.predict(x)

如果每次生成新进程时不锁定图形并运行变量初始值设定项，则一切正常。（除了，每次调用都会有大约30-90 MB的内存泄漏，这对python内存分析器是不可见的）。当我想锁定图形时，我会收到有关未初始化变量的错误：

FailedPreconditionError (see above for traceback): 
Attempting to use uninitialized value gru_1/bias
       [[Node: gru_1/bias/read = Identity[T=DT_FLOAT, _class=["loc:@gru_1/bias"],
       _device="/job:local/replica:0/task:0/cpu:0"](gru_1/bias)]]

提前谢谢！在

Answer 1

我不确定这是否对您有帮助，但是需要知道在tensorflow中，变量只为给定的Session初始化。每个Session中都需要初始化一个变量，即使在最简单的情况下也要使用它：

import tensorflow as tf

x = tf.Variable(0.)

with tf.Session() as sess:
    tf.global_variables_initializer().run()
    # x is initialized   no issue here
    x.eval()

with tf.Session() as sess:
    x.eval()
    # Error   x was never initialized in this session, even though
    # it has been initialized before in another session

Answer 2

你考虑过TensorFlow服务吗？https://www.tensorflow.org/serving/

一般来说，您希望缓存会话，我认为这是TF Serving使用的策略。这将是迄今为止将TF模型部署到数据中心的最佳体验。在

您也可以转到另一个方向，^{}，这样就不需要会话了。变量仍然会被初始化，尽管在创建Python变量对象时会立即初始化。在

但是如果您真的想创建和销毁会话，可以用常量（"freeze" it）替换图中的变量。在本例中，我还考虑禁用图优化，因为第一个带有一组新的feed和fetch的session.run调用将在默认情况下花费一些时间来优化图（通过GraphOptionsproto中的RewriterConfig进行配置）。在

（引自对该问题的评论）