快速开始函数式（Functional）模型

我们起初将Functional一词译作泛型，想要表达该类模型能够表达任意张量映射的含义，但表达的不是很精确，在Keras 2里我们将这个词改译为“函数式”，对函数式编程有所了解的同学应能够快速get到该类模型想要表达的含义。函数式模型称作Functional，但它的类名是Model，因此我们有时候也用Model来代表函数式模型。

Keras函数式模型接口是用户定义多输出模型、非循环有向模型或具有共享层的模型等复杂模型的途径。一句话，只要你的模型不是类似VGG一样一条路走到黑的模型，或者你的模型需要多于一个的输出，那么你总应该选择函数式模型。函数式模型是最广泛的一类模型，序贯模型（Sequential）只是它的一种特殊情况。

这部分的文档假设你已经对Sequential模型已经比较熟悉

让我们从简单一点的模型开始

第一个模型：全连接网络

Sequential当然是实现全连接网络的最好方式，但我们从简单的全连接网络开始，有助于我们学习这部分的内容。在开始前，有几个概念需要澄清：

  • 层对象接受张量为参数，返回一个张量。

  • 输入是张量，输出也是张量的一个框架就是一个模型，通过Model定义。

  • 这样的模型可以被像Keras的Sequential一样被训练

  1. from keras.layers import Input, Dense
  2. from keras.models import Model
  4. # This returns a tensor
  5. inputs = Input(shape=(784,))
  7. # a layer instance is callable on a tensor, and returns a tensor
  8. x = Dense(64, activation='relu')(inputs)
  9. x = Dense(64, activation='relu')(x)
  10. predictions = Dense(10, activation='softmax')(x)
  12. # This creates a model that includes
  13. # the Input layer and three Dense layers
  14. model = Model(inputs=inputs, outputs=predictions)
  15. model.compile(optimizer='rmsprop',
  16.               loss='categorical_crossentropy',
  17.               metrics=['accuracy'])
  18. model.fit(data, labels)  # starts training

所有的模型都是可调用的，就像层一样

利用函数式模型的接口，我们可以很容易的重用已经训练好的模型：你可以把模型当作一个层一样，通过提供一个tensor来调用它。注意当你调用一个模型时，你不仅仅重用了它的结构，也重用了它的权重。

  1. x = Input(shape=(784,))
  2. # This works, and returns the 10-way softmax we defined above.
  3. y = model(x)

这种方式可以允许你快速的创建能处理序列信号的模型，你可以很快将一个图像分类的模型变为一个对视频分类的模型，只需要一行代码：

  1. from keras.layers import TimeDistributed
  3. # Input tensor for sequences of 20 timesteps,
  4. # each containing a 784-dimensional vector
  5. input_sequences = Input(shape=(20, 784))
  7. # This applies our previous model to every timestep in the input sequences.
  8. # the output of the previous model was a 10-way softmax,
  9. # so the output of the layer below will be a sequence of 20 vectors of size 10.
  10. processed_sequences = TimeDistributed(model)(input_sequences)

多输入和多输出模型

使用函数式模型的一个典型场景是搭建多输入、多输出的模型。

考虑这样一个模型。我们希望预测Twitter上一条新闻会被转发和点赞多少次。模型的主要输入是新闻本身，也就是一个词语的序列。但我们还可以拥有额外的输入，如新闻发布的日期等。这个模型的损失函数将由两部分组成，辅助的损失函数评估仅仅基于新闻本身做出预测的情况，主损失函数评估基于新闻和额外信息的预测的情况，即使来自主损失函数的梯度发生弥散，来自辅助损失函数的信息也能够训练Embeddding和LSTM层。在模型中早点使用主要的损失函数是对于深度网络的一个良好的正则方法。总而言之，该模型框图如下：

multi-input-multi-output-graph

让我们用函数式模型来实现这个框图

主要的输入接收新闻本身，即一个整数的序列（每个整数编码了一个词）。这些整数位于1到10，000之间（即我们的字典有10，000个词）。这个序列有100个单词。

  1. from keras.layers import Input, Embedding, LSTM, Dense
  2. from keras.models import Model
  4. # Headline input: meant to receive sequences of 100 integers, between 1 and 10000.
  5. # Note that we can name any layer by passing it a "name" argument.
  6. main_input = Input(shape=(100,), dtype='int32', name='main_input')
  8. # This embedding layer will encode the input sequence
  9. # into a sequence of dense 512-dimensional vectors.
  10. x = Embedding(output_dim=512, input_dim=10000, input_length=100)(main_input)
  12. # A LSTM will transform the vector sequence into a single vector,
  13. # containing information about the entire sequence
  14. lstm_out = LSTM(32)(x)

然后，我们插入一个额外的损失，使得即使在主损失很高的情况下，LSTM和Embedding层也可以平滑的训练。

  1. auxiliary_output = Dense(1, activation='sigmoid', name='aux_output')(lstm_out)

再然后，我们将LSTM与额外的输入数据串联起来组成输入，送入模型中：

  1. auxiliary_input = Input(shape=(5,), name='aux_input')
  2. x = keras.layers.concatenate([lstm_out, auxiliary_input])
  4. # We stack a deep densely-connected network on top
  5. x = Dense(64, activation='relu')(x)
  6. x = Dense(64, activation='relu')(x)
  7. x = Dense(64, activation='relu')(x)
  9. # And finally we add the main logistic regression layer
  10. main_output = Dense(1, activation='sigmoid', name='main_output')(x)

最后，我们定义整个2输入，2输出的模型：

  1. model = Model(inputs=[main_input, auxiliary_input], outputs=[main_output, auxiliary_output])

模型定义完毕，下一步编译模型。我们给额外的损失赋0.2的权重。我们可以通过关键字参数loss_weights或loss来为不同的输出设置不同的损失函数或权值。这两个参数均可为Python的列表或字典。这里我们给loss传递单个损失函数，这个损失函数会被应用于所有输出上。

  1. model.compile(optimizer='rmsprop', loss='binary_crossentropy',
  2.               loss_weights=[1., 0.2])

编译完成后，我们通过传递训练数据和目标值训练该模型：

  1. model.fit([headline_data, additional_data], [labels, labels],
  2.           epochs=50, batch_size=32)

因为我们输入和输出是被命名过的（在定义时传递了“name”参数），我们也可以用下面的方式编译和训练模型：

  1. model.compile(optimizer='rmsprop',
  2.               loss={'main_output': 'binary_crossentropy', 'aux_output': 'binary_crossentropy'},
  3.               loss_weights={'main_output': 1., 'aux_output': 0.2})
  5. # And trained it via:
  6. model.fit({'main_input': headline_data, 'aux_input': additional_data},
  7.           {'main_output': labels, 'aux_output': labels},
  8.           epochs=50, batch_size=32)

共享层

另一个使用函数式模型的场合是使用共享层的时候。

考虑微博数据，我们希望建立模型来判别两条微博是否是来自同一个用户，这个需求同样可以用来判断一个用户的两条微博的相似性。

一种实现方式是，我们建立一个模型，它分别将两条微博的数据映射到两个特征向量上，然后将特征向量串联并加一个logistic回归层，输出它们来自同一个用户的概率。这种模型的训练数据是一对对的微博。

因为这个问题是对称的，所以处理第一条微博的模型当然也能重用于处理第二条微博。所以这里我们使用一个共享的LSTM层来进行映射。

首先，我们将微博的数据转为（140，256）的矩阵，即每条微博有140个字符，每个单词的特征由一个256维的词向量表示，向量的每个元素为1表示某个字符出现，为0表示不出现，这是一个one-hot编码。

之所以是（140，256）是因为一条微博最多有140个字符，而扩展的ASCII码表编码了常见的256个字符。原文中此处为Tweet，所以对外国人而言这是合理的。如果考虑中文字符，那一个单词的词向量就不止256了。

  1. import keras
  2. from keras.layers import Input, LSTM, Dense
  3. from keras.models import Model
  5. tweet_a = Input(shape=(140, 256))
  6. tweet_b = Input(shape=(140, 256))

若要对不同的输入共享同一层，就初始化该层一次，然后多次调用它

  1. # This layer can take as input a matrix
  2. # and will return a vector of size 64
  3. shared_lstm = LSTM(64)
  5. # When we reuse the same layer instance
  6. # multiple times, the weights of the layer
  7. # are also being reused
  8. # (it is effectively *the same* layer)
  9. encoded_a = shared_lstm(tweet_a)
  10. encoded_b = shared_lstm(tweet_b)
  12. # We can then concatenate the two vectors:
  13. merged_vector = keras.layers.concatenate([encoded_a, encoded_b], axis=-1)
  15. # And add a logistic regression on top
  16. predictions = Dense(1, activation='sigmoid')(merged_vector)
  18. # We define a trainable model linking the
  19. # tweet inputs to the predictions
  20. model = Model(inputs=[tweet_a, tweet_b], outputs=predictions)
  22. model.compile(optimizer='rmsprop',
  23.               loss='binary_crossentropy',
  24.               metrics=['accuracy'])
  25. model.fit([data_a, data_b], labels, epochs=10)

先暂停一下，看看共享层到底输出了什么，它的输出数据shape又是什么

层“节点”的概念

无论何时，当你在某个输入上调用层时，你就创建了一个新的张量（即该层的输出），同时你也在为这个层增加一个“（计算）节点”。这个节点将输入张量映射为输出张量。当你多次调用该层时，这个层就有了多个节点，其下标分别为0，1，2…

在上一版本的Keras中，你可以通过layer.get_output()方法来获得层的输出张量，或者通过layer.output_shape获得其输出张量的shape。这个版本的Keras你仍然可以这么做（除了layer.get_output()被output替换）。但如果一个层与多个输入相连，会出现什么情况呢？

如果层只与一个输入相连，那没有任何困惑的地方。.output将会返回该层唯一的输出

  1. a = Input(shape=(140, 256))
  3. lstm = LSTM(32)
  4. encoded_a = lstm(a)
  6. assert lstm.output == encoded_a

但当层与多个输入相连时，会出现问题

  1. a = Input(shape=(140, 256))
  2. b = Input(shape=(140, 256))
  4. lstm = LSTM(32)
  5. encoded_a = lstm(a)
  6. encoded_b = lstm(b)
  8. lstm.output

上面这段代码会报错

  1. >> AssertionError: Layer lstm_1 has multiple inbound nodes,
  2. hence the notion of "layer output" is ill-defined.
  3. Use `get_output_at(node_index)` instead.

通过下面这种调用方式即可解决

  1. assert lstm.get_output_at(0) == encoded_a
  2. assert lstm.get_output_at(1) == encoded_b

对于input_shape和output_shape也是一样，如果一个层只有一个节点，或所有的节点都有相同的输入或输出shape，那么input_shape和output_shape都是没有歧义的，并也只返回一个值。但是，例如你把一个相同的Conv2D应用于一个大小为(32,32,3)的数据，然后又将其应用于一个(64,64,3)的数据，那么此时该层就具有了多个输入和输出的shape，你就需要显式的指定节点的下标，来表明你想取的是哪个了

  1. a = Input(shape=(32, 32, 3))
  2. b = Input(shape=(64, 64, 3))
  4. conv = Conv2D(16, (3, 3), padding='same')
  5. conved_a = conv(a)
  7. # Only one input so far, the following will work:
  8. assert conv.input_shape == (None, 32, 32, 3)
  10. conved_b = conv(b)
  11. # now the `.input_shape` property wouldn't work, but this does:
  12. assert conv.get_input_shape_at(0) == (None, 32, 32, 3)
  13. assert conv.get_input_shape_at(1) == (None, 64, 64, 3)

更多的例子

代码示例依然是学习的最佳方式，这里是更多的例子

inception模型

inception的详细结构参见Google的这篇论文：Going Deeper with Convolutions

  1. from keras.layers import Conv2D, MaxPooling2D, Input
  3. input_img = Input(shape=(256, 256, 3))
  5. tower_1 = Conv2D(64, (1, 1), padding='same', activation='relu')(input_img)
  6. tower_1 = Conv2D(64, (3, 3), padding='same', activation='relu')(tower_1)
  8. tower_2 = Conv2D(64, (1, 1), padding='same', activation='relu')(input_img)
  9. tower_2 = Conv2D(64, (5, 5), padding='same', activation='relu')(tower_2)
  11. tower_3 = MaxPooling2D((3, 3), strides=(1, 1), padding='same')(input_img)
  12. tower_3 = Conv2D(64, (1, 1), padding='same', activation='relu')(tower_3)
  14. output = keras.layers.concatenate([tower_1, tower_2, tower_3], axis=1)

卷积层的残差连接

残差网络（Residual Network）的详细信息请参考这篇文章：Deep Residual Learning for Image Recognition

  1. from keras.layers import Conv2D, Input
  3. # input tensor for a 3-channel 256x256 image
  4. x = Input(shape=(256, 256, 3))
  5. # 3x3 conv with 3 output channels (same as input channels)
  6. y = Conv2D(3, (3, 3), padding='same')(x)
  7. # this returns x + y.
  8. z = keras.layers.add([x, y])

共享视觉模型

该模型在两个输入上重用了图像处理的模型，用来判别两个MNIST数字是否是相同的数字

  1. from keras.layers import Conv2D, MaxPooling2D, Input, Dense, Flatten
  2. from keras.models import Model
  4. # First, define the vision modules
  5. digit_input = Input(shape=(27, 27, 1))
  6. x = Conv2D(64, (3, 3))(digit_input)
  7. x = Conv2D(64, (3, 3))(x)
  8. x = MaxPooling2D((2, 2))(x)
  9. out = Flatten()(x)
  11. vision_model = Model(digit_input, out)
  13. # Then define the tell-digits-apart model
  14. digit_a = Input(shape=(27, 27, 1))
  15. digit_b = Input(shape=(27, 27, 1))
  17. # The vision model will be shared, weights and all
  18. out_a = vision_model(digit_a)
  19. out_b = vision_model(digit_b)
  21. concatenated = keras.layers.concatenate([out_a, out_b])
  22. out = Dense(1, activation='sigmoid')(concatenated)
  24. classification_model = Model([digit_a, digit_b], out)

视觉问答模型

在针对一幅图片使用自然语言进行提问时，该模型能够提供关于该图片的一个单词的答案

这个模型将自然语言的问题和图片分别映射为特征向量，将二者合并后训练一个logistic回归层，从一系列可能的回答中挑选一个。

  1. from keras.layers import Conv2D, MaxPooling2D, Flatten
  2. from keras.layers import Input, LSTM, Embedding, Dense
  3. from keras.models import Model, Sequential
  5. # First, let's define a vision model using a Sequential model.
  6. # This model will encode an image into a vector.
  7. vision_model = Sequential()
  8. vision_model.add(Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=(224, 224, 3)))
  9. vision_model.add(Conv2D(64, (3, 3), activation='relu'))
  10. vision_model.add(MaxPooling2D((2, 2)))
  11. vision_model.add(Conv2D(128, (3, 3), activation='relu', padding='same'))
  12. vision_model.add(Conv2D(128, (3, 3), activation='relu'))
  13. vision_model.add(MaxPooling2D((2, 2)))
  14. vision_model.add(Conv2D(256, (3, 3), activation='relu', padding='same'))
  15. vision_model.add(Conv2D(256, (3, 3), activation='relu'))
  16. vision_model.add(Conv2D(256, (3, 3), activation='relu'))
  17. vision_model.add(MaxPooling2D((2, 2)))
  18. vision_model.add(Flatten())
  20. # Now let's get a tensor with the output of our vision model:
  21. image_input = Input(shape=(224, 224, 3))
  22. encoded_image = vision_model(image_input)
  24. # Next, let's define a language model to encode the question into a vector.
  25. # Each question will be at most 100 word long,
  26. # and we will index words as integers from 1 to 9999.
  27. question_input = Input(shape=(100,), dtype='int32')
  28. embedded_question = Embedding(input_dim=10000, output_dim=256, input_length=100)(question_input)
  29. encoded_question = LSTM(256)(embedded_question)
  31. # Let's concatenate the question vector and the image vector:
  32. merged = keras.layers.concatenate([encoded_question, encoded_image])
  34. # And let's train a logistic regression over 1000 words on top:
  35. output = Dense(1000, activation='softmax')(merged)
  37. # This is our final model:
  38. vqa_model = Model(inputs=[image_input, question_input], outputs=output)
  40. # The next stage would be training this model on actual data.

视频问答模型

在做完图片问答模型后，我们可以快速将其转为视频问答的模型。在适当的训练下，你可以为模型提供一个短视频（如100帧）然后向模型提问一个关于该视频的问题，如“what sport is the boy playing？”->“football”

  1. from keras.layers import TimeDistributed
  3. video_input = Input(shape=(100, 224, 224, 3))
  4. # This is our video encoded via the previously trained vision_model (weights are reused)
  5. encoded_frame_sequence = TimeDistributed(vision_model)(video_input)  # the output will be a sequence of vectors
  6. encoded_video = LSTM(256)(encoded_frame_sequence)  # the output will be a vector
  8. # This is a model-level representation of the question encoder, reusing the same weights as before:
  9. question_encoder = Model(inputs=question_input, outputs=encoded_question)
  11. # Let's use it to encode the question:
  12. video_question_input = Input(shape=(100,), dtype='int32')
  13. encoded_video_question = question_encoder(video_question_input)
  15. # And this is our video question answering model:
  16. merged = keras.layers.concatenate([encoded_video, encoded_video_question])
  17. output = Dense(1000, activation='softmax')(merged)
  18. video_qa_model = Model(inputs=[video_input, video_question_input], outputs=output)