Keras - 保存mnist数据集的图像嵌入

Question

我已经为MNIST数据库编写了下面这个简单的MLP网络。

from __future__ import print_function

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras import callbacks


batch_size = 100
num_classes = 10
epochs = 20

tb = callbacks.TensorBoard(log_dir='/Users/shlomi.shwartz/tensorflow/notebooks/logs/minist', histogram_freq=10, batch_size=32,
                           write_graph=True, write_grads=True, write_images=True,
                           embeddings_freq=10, embeddings_layer_names=None,
                           embeddings_metadata=None)

early_stop = callbacks.EarlyStopping(monitor='val_loss', min_delta=0,
                     patience=3, verbose=1, mode='auto')


# the data, shuffled and split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()

x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')

# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

model = Sequential()
model.add(Dense(200, activation='relu', input_shape=(784,)))
model.add(Dropout(0.2))
model.add(Dense(100, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(60, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(30, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))

model.summary()

model.compile(loss='categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

history = model.fit(x_train, y_train,
                    callbacks=[tb,early_stop],
                    batch_size=batch_size,
                    epochs=epochs,
                    verbose=1,
                    validation_data=(x_test, y_test))
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

模型运行良好，我可以在TensorBoard上看到标量信息。但是当我将 embeddings_freq=10 更改为尝试可视化图像（类似于此处所示）时，出现了以下错误：

Traceback (most recent call last):
  File "/Users/shlomi.shwartz/IdeaProjects/TF/src/minist.py", line 65, in <module>
    validation_data=(x_test, y_test))
  File "/Users/shlomi.shwartz/tensorflow/lib/python3.6/site-packages/keras/models.py", line 870, in fit
    initial_epoch=initial_epoch)
  File "/Users/shlomi.shwartz/tensorflow/lib/python3.6/site-packages/keras/engine/training.py", line 1507, in fit
    initial_epoch=initial_epoch)
  File "/Users/shlomi.shwartz/tensorflow/lib/python3.6/site-packages/keras/engine/training.py", line 1117, in _fit_loop
    callbacks.set_model(callback_model)
  File "/Users/shlomi.shwartz/tensorflow/lib/python3.6/site-packages/keras/callbacks.py", line 52, in set_model
    callback.set_model(model)
  File "/Users/shlomi.shwartz/tensorflow/lib/python3.6/site-packages/keras/callbacks.py", line 719, in set_model
    self.saver = tf.train.Saver(list(embeddings.values()))
  File "/usr/local/Cellar/python3/3.6.1/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/training/saver.py", line 1139, in __init__
    self.build()
  File "/usr/local/Cellar/python3/3.6.1/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/training/saver.py", line 1161, in build
    raise ValueError("No variables to save")
ValueError: No variables to save

问：我错过了什么？这是在Keras中做事的正确方式吗？

更新：我知道使用嵌入投影有一些前提条件，但我还没有找到一个好的Keras教程来实现它，任何帮助都将不胜感激。

- Shlomi Schwartz

---

在你将embeddings_freq的值更改为10并出现错误之前，它的值是多少？ - DarkCygnus

该值为零。 - Shlomi Schwartz

请问您能否澄清Keras和Tensorflow的版本，并确认您使用的是Python 3.6.1？ - desertnaut

Keras 2.0 TF 1.2 Python 3.6.1 - Shlomi Schwartz

Answer 1

在callbacks.TensorBoard中所谓的"embedding"，广义上指的是任何层的权重。根据Keras documentation:

embeddings_layer_names: 要监视的层名称列表。如果为None或空列表，则将监视所有嵌入层。

因此，默认情况下，它将监视Embedding层，但你不一定需要Embedding层来使用这个可视化工具。

在您提供的MLP示例中，缺少embeddings_layer_names参数。您需要确定要可视化的层。假设您想要可视化所有Dense层的权重（或者在Keras中称为“kernel”），可以像这样指定embeddings_layer_names:

model = Sequential()
model.add(Dense(200, activation='relu', input_shape=(784,)))
model.add(Dropout(0.2))
model.add(Dense(100, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(60, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(30, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))

embedding_layer_names = set(layer.name
                            for layer in model.layers
                            if layer.name.startswith('dense_'))

tb = callbacks.TensorBoard(log_dir='temp', histogram_freq=10, batch_size=32,
                           write_graph=True, write_grads=True, write_images=True,
                           embeddings_freq=10, embeddings_metadata=None,
                           embeddings_layer_names=embedding_layer_names)

model.compile(...)
model.fit(...)

然后，您可以在TensorBoard中看到类似于以下内容：

如果您想弄清楚关于embeddings_layer_names正在发生什么，可以查看Keras源代码中的相关行。

---

编辑：

这里有一个用于可视化层输出的简单解决方案。由于原始的TensorBoard回调不支持此功能，因此实现新回调似乎是不可避免的。

由于重新编写整个TensorBoard回调需要占用大量页面空间，因此我将扩展原始TensorBoard并写出不同的部分（已经相当冗长）。但为了避免重复计算和模型保存，重新编写TensorBoard回调将是更好、更清晰的方法。

import tensorflow as tf
from tensorflow.contrib.tensorboard.plugins import projector
from keras import backend as K
from keras.models import Model
from keras.callbacks import TensorBoard

class TensorResponseBoard(TensorBoard):
    def __init__(self, val_size, img_path, img_size, **kwargs):
        super(TensorResponseBoard, self).__init__(**kwargs)
        self.val_size = val_size
        self.img_path = img_path
        self.img_size = img_size

    def set_model(self, model):
        super(TensorResponseBoard, self).set_model(model)

        if self.embeddings_freq and self.embeddings_layer_names:
            embeddings = {}
            for layer_name in self.embeddings_layer_names:
                # initialize tensors which will later be used in `on_epoch_end()` to
                # store the response values by feeding the val data through the model
                layer = self.model.get_layer(layer_name)
                output_dim = layer.output.shape[-1]
                response_tensor = tf.Variable(tf.zeros([self.val_size, output_dim]),
                                              name=layer_name + '_response')
                embeddings[layer_name] = response_tensor

            self.embeddings = embeddings
            self.saver = tf.train.Saver(list(self.embeddings.values()))

            response_outputs = [self.model.get_layer(layer_name).output
                                for layer_name in self.embeddings_layer_names]
            self.response_model = Model(self.model.inputs, response_outputs)

            config = projector.ProjectorConfig()
            embeddings_metadata = {layer_name: self.embeddings_metadata
                                   for layer_name in embeddings.keys()}

            for layer_name, response_tensor in self.embeddings.items():
                embedding = config.embeddings.add()
                embedding.tensor_name = response_tensor.name

                # for coloring points by labels
                embedding.metadata_path = embeddings_metadata[layer_name]

                # for attaching images to the points
                embedding.sprite.image_path = self.img_path
                embedding.sprite.single_image_dim.extend(self.img_size)

            projector.visualize_embeddings(self.writer, config)

    def on_epoch_end(self, epoch, logs=None):
        super(TensorResponseBoard, self).on_epoch_end(epoch, logs)

        if self.embeddings_freq and self.embeddings_ckpt_path:
            if epoch % self.embeddings_freq == 0:
                # feeding the validation data through the model
                val_data = self.validation_data[0]
                response_values = self.response_model.predict(val_data)
                if len(self.embeddings_layer_names) == 1:
                    response_values = [response_values]

                # record the response at each layers we're monitoring
                response_tensors = []
                for layer_name in self.embeddings_layer_names:
                    response_tensors.append(self.embeddings[layer_name])
                K.batch_set_value(list(zip(response_tensors, response_values)))

                # finally, save all tensors holding the layer responses
                self.saver.save(self.sess, self.embeddings_ckpt_path, epoch)

使用它：

tb = TensorResponseBoard(log_dir=log_dir, histogram_freq=10, batch_size=10,
                         write_graph=True, write_grads=True, write_images=True,
                         embeddings_freq=10,
                         embeddings_layer_names=['dense_1'],
                         embeddings_metadata='metadata.tsv',
                         val_size=len(x_test), img_path='images.jpg', img_size=[28, 28])

在启动TensorBoard之前，您需要将标签和图像保存到log_dir以进行可视化：

from PIL import Image
img_array = x_test.reshape(100, 100, 28, 28)
img_array_flat = np.concatenate([np.concatenate([x for x in row], axis=1) for row in img_array])
img = Image.fromarray(np.uint8(255 * (1. - img_array_flat)))
img.save(os.path.join(log_dir, 'images.jpg'))
np.savetxt(os.path.join(log_dir, 'metadata.tsv'), np.where(y_test)[1], fmt='%d')

这是结果：

- Yu-Yang

---

谢谢回复，我真正想要的是显示图片，这样我就可以看到模型是否将它们分组。您的答案中应该改变什么，才能让我看到这些图片呢？ - Shlomi Schwartz

所以你想要可视化的实际上不是模型的任何层权重，而是通过将图像输入模型后得到的响应（或预测）。我认为目前在任何Keras回调中都没有实现这一点。在当前的Keras框架下，回调只提供了model和logs（即损失和指标），但没有任何层的响应。 - Yu-Yang

我已经更新了答案，提供了一个解决方法。请看看是否符合您的要求。 - Yu-Yang

我无法复制这个示例。我正在使用1.7.0 Tensorflow和2.1.5 Keras。这里使用的版本是什么？ - user42361

@user42361 我已经在1.7.0的tensorflow和2.1.5的keras上尝试了相同的代码，没有任何问题。 - Yu-Yang

Answer 2

您需要在Keras中至少有一个嵌入层。关于它们，Stats上有一个很好的解释。虽然不是直接针对Keras，但概念大致相同。神经网络中的嵌入层是什么？

- Carsten

---

看看Yu-Yang的评论。他有一种使用TensorFlow嵌入可视化的方法，而不需要使用嵌入层。 - Carsten

是的，然而使用这种方法我只能看到空间中的点，我想将这些点连接到实际的图形上。 - Shlomi Schwartz

Answer 3

因此，我得出结论，你实际上想要（从你的帖子中并不完全清楚）以类似于this Tensorboard demo的方式可视化模型的预测结果。

首先，即使在Tensorflow中，复制这个东西也是非常困难的even in Tensorflow。该演示文稿对诸如metadata & sprite images之类的必要内容只有非常简短和过渡性的提及，以便获得这样的可视化效果。

底线：虽然不容易，但确实可以使用Keras完成。 您不需要Keras回调； 您所需要的只是您的模型预测、必要的元数据和精灵图像以及一些纯TensorFlow代码。 所以， 步骤1 - 获取测试集的模型预测结果：

emb = model.predict(x_test) # 'emb' for embedding

步骤2a - 建立一个包含测试集真实标签的元数据文件：

import numpy as np

LOG_DIR = '/home/herc/SO/tmp'  # FULL PATH HERE!!!

metadata_file = os.path.join(LOG_DIR, 'metadata.tsv')
with open(metadata_file, 'w') as f:
    for i in range(len(y_test)):
        c = np.nonzero(y_test[i])[0][0]
        f.write('{}\n'.format(c))

第2b步 - 获取TensorFlow团队提供的精灵图像mnist_10k_sprite.png（在此处），并将其放置在您的LOG_DIR中。

第3步 - 编写一些Tensorflow代码：

import tensorflow as tf
from tensorflow.contrib.tensorboard.plugins import projector

embedding_var = tf.Variable(emb,  name='final_layer_embedding')
sess = tf.Session()
sess.run(embedding_var.initializer)
summary_writer = tf.summary.FileWriter(LOG_DIR)
config = projector.ProjectorConfig()
embedding = config.embeddings.add()
embedding.tensor_name = embedding_var.name

# Specify the metadata file:
embedding.metadata_path = os.path.join(LOG_DIR, 'metadata.tsv')

# Specify the sprite image: 
embedding.sprite.image_path = os.path.join(LOG_DIR, 'mnist_10k_sprite.png')
embedding.sprite.single_image_dim.extend([28, 28]) # image size = 28x28

projector.visualize_embeddings(summary_writer, config)
saver = tf.train.Saver([embedding_var])
saver.save(sess, os.path.join(LOG_DIR, 'model2.ckpt'), 1)

然后，在您的LOG_DIR中运行Tensorboard，并按标签选择颜色，您将得到以下结果：

修改这个以得到其他层的预测是很简单的，尽管在这种情况下，Keras功能API可能是更好的选择。

- desertnaut