在内存中序列化和反序列化Tensorflow模型并继续训练

Question

我已经看到了这个问题的变化，但我还没有找到满意的答案。 基本上，我想从keras model.to_json() ， model.get_weights() ， model.from_json() ， model.set_weights()到tensorflow等效。 我想我已经接近那里了，但我正处于被困的地步。 如果我能在相同的字符串中获得权重和图表，我更愿意，但我明白这是不可能的。

目前，我所拥有的是：

g = optimizer.minimize(loss_op,
                       global_step=tf.train.get_global_step())
de = g.graph.as_graph_def()
json_string = json_format.MessageToJson(de)

gd = tf.GraphDef()
gd = json_format.Parse(json_string, gd)

这似乎创建了图表，但显然元图不包含在变量，权重等中。还有元图，但我唯一看到的是export_meta_graph，它似乎没有以相同的方式序列化。 我看到MetaGraph有一个proto函数，但我不知道如何序列化这些变量。

简而言之，您如何采用张量流模型（模型如权重，图形等），将其序列化为字符串（最好是json），然后对其进行反序列化并继续训练或提供预测。

以下是让我接近并且我已经尝试过的东西，但是大多数都需要写入磁盘的限制，在这种情况下我无法做到：

GitHub上的要点

这是我找到的最接近的一个，但序列化元图的链接不存在。

Answer 1

请注意，来自@Maxim的解决方案将在每次运行时在图表中创建新操作。

如果您经常运行该函数，这将导致您的代码变得越来越慢。

解决此问题的两种解决方案：

1. 与图表的其余部分同时创建分配操作并重用它们：

   assign_ops = [] for var_name in tf.trainable_variables(): assign_placeholder = tf.placeholder(var.dtype, shape=value.shape) assign_op = var.assign(assign_placeholder) assign_ops.append(assign_op)

2. 对变量使用load函数，我更喜欢这个，因为它不需要上面的代码：

   self.params = tf.trainable_variables()

   def get_weights(self): values = tf.get_default_session().run(self.params) return values

   def set_weights(self, weights): for i, value in enumerate(weights): value = np.asarray(value) self.params[i].load(value, self.sess)

（我不能评论所以我把它作为答案而不是）

Answer 2

你可以使用freeze_graph

此脚本包含在Tensorflow中，允许您获取GraphDef原型，SaverDef原型以及存储在检查点文件中的一组变量值。

通过这种方式，您可以输出一个GraphDef，其中所有变量ops都转换为包含变量值的const ops。

要恢复冻结模型，您必须重新初始化图形并重新映射冻结模型中的输入，请参阅此示例

Answer 3

如果你想要keras Model.get_weights()和Model.set_weights()的等价物，这些方法与keras内部结构并没有很强的联系，可以很容易地提取出来。

原始代码

以下是keras源代码中的外观：

def get_weights(self):
  weights = []
  for layer in self.layers:
    weights += layer.weights
  return K.batch_get_value(weights)   # this is just `get_session().run(weights)`

def set_weights(self, weights):
  tuples = []
  for layer in self.layers:
    num_param = len(layer.weights)
    layer_weights = weights[:num_param]
    for sw, w in zip(layer.weights, layer_weights):
      tuples.append((sw, w))
    weights = weights[num_param:]
  K.batch_set_value(tuples)  # another wrapper over `get_session().run(...)`

Keras的weights是numpy数组（不是json）的列表。 如您所见，它使用模型体系结构已知的事实（ self.layers ），它允许它重建从变量到值的正确映射。 一些看似非平凡的工作是在K.batch_set_value完成的，但实际上它只是准备分配操作并在会话中运行它们。

在纯张量流中获取和设置权重

def tensorflow_get_weights():
  vars = tf.trainable_variables()
  values = tf.get_default_session().run(vars)
  return zip([var.name for var in vars], values)

def tensorflow_set_weights(weights):
  assign_ops = []
  feed_dict = {}
  for var_name, value in weights:
    var = tf.get_default_session().graph.get_tensor_by_name(var_name)
    value = np.asarray(value)
    assign_placeholder = tf.placeholder(var.dtype, shape=value.shape)
    assign_op = tf.assign(var, assign_placeholder)
    assign_ops.append(assign_op)
    feed_dict[assign_placeholder] = value
  tf.get_default_session().run(assign_ops, feed_dict=feed_dict)

在这里，我假设您要序列化/反序列化整个模型（即所有可训练的变量）和默认会话。 如果不是这种情况，上述功能很容易定制。

测试

x = tf.placeholder(shape=[None, 5], dtype=tf.float32, name='x')
W = tf.Variable(np.zeros([5, 5]), dtype=tf.float32, name='W')
b = tf.Variable(np.zeros([5]), dtype=tf.float32, name='b')
y = tf.add(tf.matmul(x, W), b)

with tf.Session() as session:
  session.run(tf.global_variables_initializer())

  # Save the weights
  w = tensorflow_get_weights()
  print(W.eval(), b.eval())

  # Update the model
  session.run([tf.assign(W, np.ones([5, 5])), tf.assign(b, np.ones([5]) * 2)])
  print(W.eval(), b.eval())

  # Restore the weights
  tensorflow_set_weights(w)
  print(W.eval(), b.eval())

如果运行此测试，您应该看到模型在零处冻结，然后更新，然后恢复为零。

Answer 4

感谢Maxim帮我解决问题。 我想发布一个答案，图表和权重转换为json，适合遇到此问题的人。 为了序列化图形而不是权重，我创建了一个要点，封装了Maxim在这里写的内容： 带有非json序列化权重的Tensorflow图

现在为了序列化/反序列化图形和权重，我在这里创建了一个单独的要点： 带有json序列化权重和图形的Tensorflow图 。

为了完成解释，我首先通过不返回获取权重中的变量来略微调整权重函数，并在设置权重中抓取当前变量。 这是一个重要的警告，特别是如果图表与当前的可训练变量略有不同：

import tensorflow as tf
import numpy as np
from google.protobuf import json_format
import json

def tensorflow_get_weights():
    vs = tf.trainable_variables()
    values = tf.get_default_session().run(vs)
    return values

def tensorflow_set_weights(weights):
    assign_ops = []
    feed_dict = {}
    vs = tf.trainable_variables()
    zipped_values = zip(vs, weights)
    for var, value in zipped_values:
        value = np.asarray(value)
        assign_placeholder = tf.placeholder(var.dtype, shape=value.shape)
        assign_op = var.assign(assign_placeholder)
        assign_ops.append(assign_op)
        feed_dict[assign_placeholder] = value
    tf.get_default_session().run(assign_ops, feed_dict=feed_dict)

接下来，我创建了两个实用程序函数，用于将权重转换为json：

def convert_weights_to_json(weights):
    weights = [w.tolist() for w in weights]
    weights_list = json.dumps(weights)
    return weights_list

def convert_json_to_weights(json_weights):
    loaded_weights = json.loads(json_weights)
    loaded_weights = [np.asarray(x) for x in loaded_weights]
    return loaded_weights

比我有一个最初开始训练的方法。 此方法将初始化变量，运行优化，获取权重和图形，并将它们转换为json。 看起来像：

def run_initial_with_json_weights(opti, feed_dict):
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        for i in range(0, 250):
            sess.run(opti, feed_dict=feed_dict)
        first_weights = tensorflow_get_weights()
        g = tf.get_default_graph().as_graph_def()
    json_string = json_format.MessageToJson(g)
    return json_string, convert_weights_to_json(first_weights)

现在我们已经有序列化的权重和图表，如果我们想继续训练和/或做出预测，我们可以做到以下几点。 此方法反序列化graphdef和权重，运行优化，然后进行预测。

def run_serialized(json_graph, json_weights, feed_dict):
    gd = tf.GraphDef()
    gd = json_format.Parse(json_graph, gd)
    weights = convert_json_to_weights(json_weights)

    with tf.Session() as sess:
        tf.import_graph_def(gd)
        sess.run(tf.global_variables_initializer())
        nu_out = tf.get_default_graph().get_tensor_by_name('outer/Sigmoid:0')
        mini = tf.get_default_graph().get_tensor_by_name('mini:0')
        tensorflow_set_weights(weights)

        for i in range(0, 50):
             sess.run(mini, feed_dict=feed_dict)

        predicted = sess.run(nu_out, feed_dict=feed_dict)

    return predicted

完整的xor示例在上面的要点中。