热门标签
热门文章
- 1python3.6安装numpy-Python3.6的组件numpy的安装
- 2dataX同步SQLserver到MySQL数据
- 38家大厂SSP offer的清华学长谈算法岗是否人间地狱（送七本学长手写iPad笔记）_本科就拿到大厂sspoffer
- 4iOS 平台 TestFlight 外部测试邀请码优化方案_hidecat邀请码
- 5【调试笔记-20240619-Windows- Tauri + Vite + Vue + TS 显示系统信息】
- 6c++创建二叉树_数据结构：查找（4）|| 平衡二叉树
- 7【开源推荐】微信小程序&公众号商城管理系统_公众号微商营销平台 开源
- 8【Python】进阶学习：pandas--read_excel()函数的基本使用_pd.read.excel
- 9基于Echarts构建大数据招聘岗位数据可视化大屏_基于echart高校教师队伍大数据页面_数据可视化echarts使用条形统计图展示各城市数量,使用饼图展示岗位要求
- 10Redis点击 redis-server.exe 出现闪退的解决方法_redis-server.exe闪退
当前位置: article > 正文
深度学习图像描述生成：使用注意力机制生成的场景描述
作者：知新_RL | 2024-06-15 06:08:25
赞
踩
图像描述生成
开发环境
作者：嘟粥yyds
时间：2023年7月14日
集成开发工具：Google Colab
集成开发环境：Python 3.10.6
第三方库：tensorflow、tensorflow_datasets、tensorflow_hub、matplotlib、textwrap、numpy、time
概要
实现具有视觉注意力的图像描述，本文要点如下：
- 了解如何创建图像描述模型
- 了解如何训练和预测文本生成模型。
图像描述模型将图像作为输入，并输出文本。理想情况下，我们希望模型的输出能够准确描述图像中的事件/事物，类似于人类可能提供的描述。
例如，给定如下例所示的图像，模型预计将生成诸如“有些人正在打棒球。”的标题。
为了生成文本，我们构建了一个编码器-解码器模型，其中编码器输出输入图像的嵌入，解码器从图像嵌入中输出文本
本文将使用类似于Show, Attend and Tell: Neural Image Caption Generation with Visual Attention的模型架构，并构建基于注意力的图像描述模型。
本文使用的训练集为COCO大规模目标检测、分割、描述数据集。
实现步骤
1 导入TensorFlow和其他所需库
import time from textwrap import wrap # 用于对文本进行换行处理 import matplotlib.pylab as plt import numpy as np import tensorflow as tf import tensorflow_datasets as tfds import tensorflow_hub as hub from tensorflow.keras import Input from tensorflow.keras.layers import ( GRU, Add, AdditiveAttention, Attention, Concatenate, Dense, Embedding, LayerNormalization, Reshape, StringLookup, TextVectorization, ) print(tf.version.VERSION)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
2 读取和准备数据集
我们将使用TensorFlow数据集功能来读取COCO标题数据集。
此版本包含来自COCO 2014的图像、边界框、标签和描述，分为Karpathy和Li（2015）定义的子集，并采用处理原始数据集的一些数据质量问题（例如，一些原始数据集中的图像没有标题）
首先，让我们定义一些常量。
本文使用的是来自 tf.keras.applications 的预训练InceptionResNetV2模型作为特征提取器，因此一些常量来自InceptionResNetV2模型定义。如果您想使用其他类型的基本模型，请确保也更改这些常数。
tf.keras.applications是一个预训练的模型存储库，类似于TensorFlow Hub，虽然Tensorflow Hub托管不同模式的模型，包括图像、文本、音频等，但tf.keras.application仅托管流行且稳定的图像模型。
相比之下，tf.keras.applications更灵活，因为它包含模型元数据，允许我们访问和控制模型行为，而大多数基于TensorFlow Hub的模型只包含编译后的SavedModels。
# 改变这些以控制精度/速度
VOCAB_SIZE = 20000 # 定义词汇表的大小，限制用于训练模型的单词数量。该值越小则模型收敛速度越快
ATTENTION_DIM = 512 # 指定注意力层中密集层的维度
WORD_EMBEDDING_DIM = 128 # 指定词嵌入向量的维度
# InceptionResNetV2 将(299, 299, 3)的图像作为输入并且返回(8, 8, 1536)
# 定义特征提取器模型
FEATURE_EXTRACTOR = tf.keras.applications.inception_resnet_v2.InceptionResNetV2(
include_top=False, weights="imagenet"
)
IMG_HEIGHT = 299
IMG_WIDTH = 299
IMG_CHANNELS = 3
FEATURES_SHAPE = (8, 8, 1536)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
3 过滤和预处理
在这里，我们对数据集进行预处理。下面的函数：
- 将图像调整为(
IMG_HEIGHT,IMG_WIDTH)形状 - 重新调整像素值从[0, 255]到[0, 1]
- 返回图像(
image_tensor)和描述(captions)字典。
注意：此数据集太大，无法存储在本地环境中。因此，它存储在位于us-Cental1的公共GCS存储桶中。如果您从美国以外的笔记本电脑访问它，它将速度很慢并且需要支付网络费用。
# 定义数据集所在的Google云存储(GCS)路径。 GCS_DIR = "gs://asl-public/data/tensorflow_datasets/" BUFFER_SIZE = 1000 # 定义数据集中用于缓冲和随机化的样本数。该值越大，随机化程度越高。 def get_image_label(example): """ 处理数据集中的每个样本。接收一个样本作为输入，从中提取图像和标签信息，并进行预处理。 返回包含图像张量和标题的字典 """ caption = example["captions"]["text"][0] # 每张图片只有第一个标题 img = example["image"] img = tf.image.resize(img, (IMG_HEIGHT, IMG_WIDTH)) img = img / 255 return {"image_tensor": img, "caption": caption} # 加载数据集的训练集部分 trainds = tfds.load("coco_captions", split="train", data_dir=GCS_DIR) # 对训练集中的每个样本映射为包含图像张量和标题的字典。 trainds = trainds.map( get_image_label, num_parallel_calls=tf.data.AUTOTUNE # 使用自动调整并行处理 ).shuffle(BUFFER_SIZE) # 使用prefetch函数对训练集数据进行预取，以提高数据加载的效率。 trainds = trainds.prefetch(buffer_size=tf.data.AUTOTUNE)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
4 可视化
让我们看一下数据集中的图像和示例标题。
f, ax = plt.subplots(1, 4, figsize=(20, 5))
for idx, data in enumerate(trainds.take(4)):
ax[idx].imshow(data["image_tensor"].numpy())
# 获取当前样本的标题，并将标题文本进行换行处理。即当字符串超过宽度30时进行换行
caption = "\n".join(wrap(data["caption"].numpy().decode("utf-8"), 30))
ax[idx].set_title(caption)
ax[idx].axis("off")
plt.show() # 显示图形
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
5 文本预处理
我们添加特殊的标记来表示句子的开始(<start>)和结束(<end>)。
这里添加了开始和结束标记，因为我们使用编码器-解码器模型，在预测期间，为了开始描述，我们使用<start>，并且由于描述长度可变，我们在看到<end>标记时终止预测。
然后创建标题的完整列表以供进一步预处理。
def add_start_end_token(data):
start = tf.convert_to_tensor("<start>")
end = tf.convert_to_tensor("<end>")
data["caption"] = tf.strings.join(
[start, data["caption"], end], separator=" "
)
return data
trainds = trainds.map(add_start_end_token)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
6 预处理和标记标题
本文使用的是TextVectoration层将文本标题转换为整数序列，步骤如下：
- 使用adapt遍历所有标题，将标题拆分为单词，并计算顶部
VOCAB_SIZE单词的词汇表。 - 通过将每个单词映射到词汇表中的索引来标记所有描述。所有输出序列都将填充到长度
MAX_CAPTION_LEN。这里我们直接指定64，这对于这个数据集来说已经足够了，但是请注意，如果您不想减少数据集中很长的句子，这个值应该通过处理整个数据集来计算。
注意：此过程大约需要8分钟。
# 定义标题文本的最大长度 MAX_CAPTION_LEN = 64 # 我们将覆盖TextVectoration的默认标准化以保留 # "<>" 字符，因此我们保留<start>和<end>的标记。 def standardize(inputs): """ 标准化文本数据。接收一个文本输入inputs，将其转换为小写并移除标点符号等特殊字符。 """ inputs = tf.strings.lower(inputs) return tf.strings.regex_replace( inputs, r"[!\"#$%&\(\)\*\+.,-/:;=?@\[\\\]^_`{|}~]?", "" ) # 从词汇表中选择最常用的单词并删除标点符号等。 tokenizer = TextVectorization( max_tokens=VOCAB_SIZE, standardize=standardize, output_sequence_length=MAX_CAPTION_LEN, ) # 使用adapt函数将文本向量化器适应到训练数据集中的标题文本 tokenizer.adapt(trainds.map(lambda x: x["caption"]))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
让我们尝试标记示例文本
tokenizer(["<start> This is a sentence <end>"])
"""输出如下:
<tf.Tensor: shape=(1, 64), dtype=int64, numpy=
array([[ 3, 165, 11, 2, 1, 4, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])>
"""
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
遍历训练数据集中的前3个样本，并将它们的标题文本提取出来。方便地查看和检查训练数据集中的一些样本标题文本，以确保数据的正确性和一致性。
sample_captions = []
for d in trainds.take(3):
sample_captions.append(d["caption"].numpy())
sample_captions
[b'<start> A man is cupping his hand near his mouth while standing in front of a group of cows in the background in a pasture. <end>',
b'<start> a plane flying through the air over some mountains <end>',
b'<start> A skater holding a trick on his board at a skate park <end>']
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
print(tokenizer(sample_captions)) """输出如下: tf.Tensor( [[ 3 2 12 11 6542 50 187 46 50 375 56 15 8 38 5 2 31 5 244 8 7 178 8 2 619 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 3 2 197 74 96 7 118 88 36 525 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 3 2 2296 26 2 303 6 50 120 21 2 253 141 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]], shape=(3, 64), dtype=int64) """
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
请注意，所有句子都以相同的标记开始和结束（例如“3”和“4”）。这些值分别表示开始标记和结束标记。
您还可以将id转换为原始文本。
for wordid in tokenizer([sample_captions[0]])[0]:
print(tokenizer.get_vocabulary()[wordid], end=" ")
"""输出如下:
<start> a man is cupping his hand near his mouth while standing in front of a group of cows in the background in a pasture <end>
"""
- 1
- 2
- 3
- 4
- 5
此外，我们可以使用StringLookup层创建Word<->索引转换器。
# 查找表：单词->索引
word_to_index = StringLookup(
mask_token="", vocabulary=tokenizer.get_vocabulary()
)
# 查找表：索引->单词
index_to_word = StringLookup(
mask_token="", vocabulary=tokenizer.get_vocabulary(), invert=True
)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
7 为训练创建tf.data数据集
现在让我们将调整后的标记化应用于所有样本，并创建tf.data数据集进行训练。
请注意，我们还通过从功能标题中转移文本来创建标签。
如果我们有一个输入标题"<start> I love cats <end>"，它的标签应该是"I love cats <end> <padding>"。
有了这个，我们的模型可以尝试从<start>学习预测I。
数据集应该返回元组，其中第一个元素是特征(image_tensor 和 caption)，第二个元素是标签（目标）。
BATCH_SIZE = 256 # 大概需要13G左右的显存，若GPU显存不足可适当调小 def create_ds_fn(data): img_tensor = data["image_tensor"] caption = tokenizer(data["caption"]) # 将数据样本中的标题文本转换为数值序列 target = tf.roll(caption, -1, 0) # 对标题文本进行滚动操作 zeros = tf.zeros([1], dtype=tf.int64) target = tf.concat((target[:-1], zeros), axis=-1) return (img_tensor, caption), target # 使批次数据集包含图像张量、标题文本和训练目标 batched_ds = ( trainds.map(create_ds_fn) .batch(BATCH_SIZE, drop_remainder=True) .prefetch(buffer_size=tf.data.AUTOTUNE) # 使用预取来提高数据加载的效率并自动调整预取的缓冲区大小 )
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
让我们看一些例子。
for (img, caption), label in batched_ds.take(2): print(f"Image shape: {img.shape}") print(f"Caption shape: {caption.shape}") print(f"Label shape: {label.shape}") print(caption[0]) print(label[0]) """输出如下: Image shape: (256, 299, 299, 3) Caption shape: (256, 64) Label shape: (256, 64) tf.Tensor( [ 3 45 10 19 140 173 14 21 7 562 5 2 94 27 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0], shape=(64,), dtype=int64) tf.Tensor( [ 45 10 19 140 173 14 21 7 562 5 2 94 27 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0], shape=(64,), dtype=int64) Image shape: (256, 299, 299, 3) Caption shape: (256, 64) Label shape: (256, 64) tf.Tensor( [ 3 2 31 5 20 14 102 2 2171 25 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0], shape=(64,), dtype=int64) tf.Tensor( [ 2 31 5 20 14 102 2 2171 25 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0], shape=(64,), dtype=int64) """
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
8 模型
现在让我们设计一个图像描述模型。它由一个图像编码器和一个描述解码器组成。
8.1 图像编码器
图像编码器模型非常简单，它通过预训练模型提取特征，并将其传递到全连接层。
- 在此示例中，我们从InceptionResNetV2的卷积层中提取特征，这给了我们一个向量（Batch Size，8, 8,1536）。
- 我们将向量重塑为（Batch Size，64, 1536）
- 我们用致密层将其压缩到
ATTENTION_DIM的长度并返回（Batch Size，64，ATTENTION_DIM） - 注意力层关注图像以预测下一个单词。
# 冻结特征提取器的权重，使其在训练过程中保持不变
FEATURE_EXTRACTOR.trainable = False
image_input = Input(shape=(IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS))
image_features = FEATURE_EXTRACTOR(image_input)
x = Reshape((FEATURES_SHAPE[0] * FEATURES_SHAPE[1], FEATURES_SHAPE[2]))(
image_features
)
encoder_output = Dense(ATTENTION_DIM, activation="relu")(x)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
encoder = tf.keras.Model(inputs=image_input, outputs=encoder_output) encoder.summary() Model: "model" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_2 (InputLayer) [(None, 299, 299, 3)] 0 inception_resnet_v2 (Functi (None, None, None, 1536) 54336736 onal) reshape (Reshape) (None, 64, 1536) 0 dense (Dense) (None, 64, 512) 786944 ================================================================= Total params: 55,123,680 Trainable params: 786,944 Non-trainable params: 54,336,736 _________________________________________________________________
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
8.2 描述解码器
描述解码器结合了一种注意力机制，专注于输入图像的不同部分。
8.2.1 注意力头
解码器使用注意力有选择地关注输入序列的一部分。
注意力将一系列向量作为每个示例的输入，并为每个示例返回一个“注意力”向量。
让我们看看这是如何工作的：
- s s s 是编码器索引。
- t t t 是解码器索引。
- α t s \alpha_{ts} αts 是注意力权重。
- h s h_s hs 是被关注的编码器输出序列（Transforme术语中的注意力“key”和“value”）。
- h t h_t ht 是处理序列的解码器状态（Transforme术语中的注意“query”）。
- c t c_t ct 是生成的上下文向量。
- a t a_t at 是结合“context”和“query”的最终输出。
方程：
- 计算注意力权重 α t s \alpha_{ts} αts，作为编码器输出序列的softmax。
- 计算context向量作为编码器输出的加权和。
最后是 s c o r e score score 函数。它的工作是为每个键查询对计算标量logit-mark。有两种常见的方法：
本文使用预定义的layers.Attention 实现Luong-style attention。
8.2.2 解码器步骤
解码器的工作是为下一个输出token生成预测。
- 解码器作为批处理接收当前单词标记。
- 它将单词标记嵌入到
ATTENTION_DIM维度。 - GRU层跟踪词嵌入，并返回GRU输出和状态。
- Bahdanau-style attention通过使用GRU输出作为查询来关注编码器的输出功能。
- attention输出和GRU输出被添加（跳过连接），并在归一化层中归一化。
- 它根据GRU输出为下一个令牌生成logit预测。
我们可以在Keras FunctionAPI中定义所有步骤，但请注意，这里我们实例化了具有可训练参数的层，以便我们在推理阶段重用层和权重。
word_input = Input(shape=(MAX_CAPTION_LEN), name="words") embed_x = Embedding(VOCAB_SIZE, ATTENTION_DIM)(word_input) decoder_gru = GRU( ATTENTION_DIM, return_sequences=True, return_state=True, ) gru_output, gru_state = decoder_gru(embed_x) decoder_atention = Attention() context_vector = decoder_atention([gru_output, encoder_output]) addition = Add()([gru_output, context_vector]) layer_norm = LayerNormalization(axis=-1) layer_norm_out = layer_norm(addition) decoder_output_dense = Dense(VOCAB_SIZE) decoder_output = decoder_output_dense(layer_norm_out)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
decoder = tf.keras.Model(
inputs=[word_input, encoder_output], outputs=decoder_output
)
tf.keras.utils.plot_model(decoder) # Google Colab已经自带了pydot和graphviz，如果是在其他环境运行则需安装这两个库
- 1
- 2
- 3
- 4
decoder.summary() Model: "model_1" _______________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to =============================================================================================== words (InputLayer) [(None, 64)] 0 [] embedding (Embedding) (None, 64, 512) 10240000 ['words[0][0]'] gru (GRU) [(None, 64, 512), 1575936 ['embedding[1][0]'] (None, 512)] input_3 (InputLayer) [(None, 64, 512)] 0 [] attention (Attention) (None, 64, 512) 0 ['gru[1][0]', 'input_3[0][0]'] add (Add) (None, 64, 512) 0 ['gru[1][0]', 'attention[1][0]'] layer_normalization (LayerNorm (None, 64, 512) 1024 ['add[1][0]'] alization) dense_1 (Dense) (None, 64, 20000) 10260000 ['layer_normalization[1][0]'] =============================================================================================== Total params: 22,076,960 Trainable params: 22,076,960 Non-trainable params: 0 _______________________________________________________________________________________________
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
9 训练模型
现在我们定义了编码器和解码器。让我们将它们组合成一个图像模型进行训练。
它有两个输入（image_input和word_input，以及一个输出(decoder_output)。此定义应与数据集管道的定义相对应。
image_caption_train_model = tf.keras.Model(
inputs=[image_input, word_input], outputs=decoder_output
)
- 1
- 2
- 3
10 损失函数
损失函数是一个简单的交叉熵，但我们在计算它时需要去掉填充(0)。所以这里我们提取句子的长度（非0部分），并仅计算有效句子部分的损失平均值。
loss_object = tf.keras.losses.SparseCategoricalCrossentropy( from_logits=True, reduction="none" ) def loss_function(real, pred): loss_ = loss_object(real, pred) mask = tf.math.logical_not(tf.math.equal(real, 0)) mask = tf.cast(mask, dtype=tf.int32) sentence_len = tf.reduce_sum(mask) loss_ = loss_[:sentence_len] # 根据句子的长度对损失值进行截断操作，避免填充部分对损失的影响。 return tf.reduce_mean(loss_, 1) image_caption_train_model.compile( optimizer="adam", loss=loss_function, )
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
11 循环训练
现在我们可以使用标准的model.fitAPI训练模型。
使用Google Colab里的NVIDIA T4 GPU训练1个epoch大约需要15分钟。本文仅训练了3个epoch，若读者有兴趣可增加epoch。
%%time
history = image_caption_train_model.fit(batched_ds, epochs=3)
"""输出如下:
Epoch 1/3
323/323 [==============================] - 1017s 3s/step - loss: 0.8762
Epoch 2/3
323/323 [==============================] - 987s 3s/step - loss: 0.4971
Epoch 3/3
323/323 [==============================] - 978s 3s/step - loss: 0.4279
CPU times: user 41min 58s, sys: 4min 38s, total: 46min 36s
Wall time: 50min 37s
"""
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
在训练阶段，模型会根据输入数据和真实标签进行训练，逐步优化权重和损失函数。但在推理阶段，我们希望能够逐步生成文本描述，而不是一次性生成完整的描述。为了实现这一目标，我们需要在生成每个单词时，将之前的状态传递给解码器，并用于生成下一个单词。
所以我们需要在描述生成期间跟踪GRU状态，并在下一个时间步骤将预测词作为输入传递给解码器。
因此，下面这段代码中创建的预测模型包含了输入层word_input、gru_state_input和encoder_output，以及输出层decoder_output和gru_state。通过将先前的状态作为输入传递给解码器，并将更新后的状态作为输出，可以在生成文本描述时保持状态的连续性，从而逐步生成合理的文本序列。
gru_state_input = Input(shape=(ATTENTION_DIM), name="gru_state_input") # 复用经过训练的GRU，但更新它以便它可以接收状态。 gru_output, gru_state = decoder_gru(embed_x, initial_state=gru_state_input) # 也复用其他层 context_vector = decoder_atention([gru_output, encoder_output]) addition_output = Add()([gru_output, context_vector]) layer_norm_output = layer_norm(addition_output) decoder_output = decoder_output_dense(layer_norm_output) # 定义具有状态输入和输出的预测模型 decoder_pred_model = tf.keras.Model( inputs=[word_input, gru_state_input, encoder_output], outputs=[decoder_output, gru_state], )
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 将GRU状态初始化为零向量。
- 预处理输入图像，将其传递给编码器，并提取图像特征。
- 设置
<start>的单词标记以开始字幕。 - 在for循环中，我们
- 将单词标记(
dec_input)、GRU状态(gru_state)和图像特征(features)传递到预测解码器并获得预测(predictions)，以及更新的GRU状态。 - 从logits中选择Top-K单词，并概率地选择一个单词，这样我们就可以避免在VOCAB_SIZE大小的向量上计算softmax。
- 当模型预测
<end>标记时停止预测。 - 将输入的单词标记替换为预测的单词标记以进行下一步。
- 将单词标记(
# 定义一个句子最小长度的阈值 MINIMUM_SENTENCE_LENGTH = 5 ## 使用训练模型的概率预测 def predict_caption(filename): # 初始化解码器状态 gru_state = tf.zeros((1, ATTENTION_DIM)) img = tf.image.decode_jpeg(tf.io.read_file(filename), channels=IMG_CHANNELS) img = tf.image.resize(img, (IMG_HEIGHT, IMG_WIDTH)) img = img / 255 features = encoder(tf.expand_dims(img, axis=0)) dec_input = tf.expand_dims([word_to_index("<start>")], 1) result = [] for i in range(MAX_CAPTION_LEN): predictions, gru_state = decoder_pred_model( [dec_input, gru_state, features] ) # 从预测给出的日志分布中选择概率最高的前k个单词 top_probs, top_idxs = tf.math.top_k( input=predictions[0][0], k=10, sorted=False ) chosen_id = tf.random.categorical([top_probs], 1)[0].numpy() predicted_id = top_idxs.numpy()[chosen_id][0] result.append(tokenizer.get_vocabulary()[predicted_id]) if predicted_id == word_to_index("<end>"): return img, result dec_input = tf.expand_dims([predicted_id], 1) return img, result
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
12 场景描述测试
# 待生成字幕的图片文件名
filename = "sample.png"
for i in range(5):
image, caption = predict_caption(filename)
print(" ".join(caption[:-1]) + ".")
img = tf.image.decode_image(tf.io.read_file(filename), channels=IMG_CHANNELS)
plt.imshow(img)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/721193
推荐阅读
相关标签
