在深度神经网络的最新发展之前，业内最聪明的人都无法解决这个问题，但是在深度神经网络问世之后，考虑到我们拥有所需的数据集，这样做是完全有可能的。

例如，网络模型可以生成与下图相关的以下任何标题，即“A white dog in a grassy area”，“white dog with brown spots”甚至“A dog on grass and some pink flowers ”。

数据集

我们选择的数据集为“ Flickr 8k”。 我们之所以选择此数据，是因为它易于访问且具有可以在普通PC上进行训练的完美大小，也足够训练网络生成适当的标题。 数据分为三组，主要是包含6k图像的训练集，包含1k图像的开发集和包含1k图像的测试集。 每个图像包含5个标题。 示例之一如下：

A child in a pink dress is climbing up a set of stairs in an entryway.

A girl going into a wooden building.

A little girl climbing into a wooden playhouse.

A little girl climbing the stairs to her playhouse.

A little girl in a pink dress going into a wooden cabin.

数据清理

任何机器学习程序的第一步也是最重要的一步是清理数据并清除所有不需要的数据。在处理标题中的文本数据时，我们将执行基本的清理步骤，例如将计算机中的所有字母都转换为小写字母“ Hey”和“ hey”是两个完全不同的单词，删除特殊标记和标点符号，例如*， (，£，$，%等)，并消除所有包含数字的单词。

我们首先为数据集中的所有唯一内容创建词汇表，即8000(图片数量)* 5(每个图像的标题)= 40000标题。我们发现它等于8763。但是这些词中的大多数只出现了1到2次，我们不希望它们出现在我们的模型中，因为这不会使我们的模型对异常值具有鲁棒性。因此，我们将词汇中包含的单词的最少出现次数设置为10个阈值，该阈值等于1652个唯一单词。

我们要做的另一件事是在每个描述中添加两个标记，以指示字幕的开始和结束。这两个标记分别是“ startseq”和“ endseq”，分别表示字幕的开始和结尾。

首先，导入所有必需的库：

importnumpyasnp
fromnumpyimportarray
importpandasaspd
importmatplotlib.pyplotasplt
importstring
importos
fromPILimportImage
importglob
importpickle
fromtimeimporttime
fromkeras.preprocessingimportsequence
fromkeras.modelsimportSequential
fromkeras.layersimportLSTM,Embedding,Dense,Flatten,Reshape,concatenate,Dropout
fromkeras.optimizersimportAdam
fromkeras.layers.mergeimportadd
fromkeras.applications.inception_v3importInceptionV3
fromkeras.preprocessingimportimage
fromkeras.modelsimportModel
fromkerasimportInput,layers
fromkeras.applications.inception_v3importpreprocess_input
fromkeras.preprocessing.sequenceimportpad_sequences
fromkeras.utilsimportto_categorical

让我们定义一些辅助函数：

#loaddescriptions
defload_doc(filename):
file=open(filename,'r')
text=file.read()
file.close()
returntext
defload_descriptions(doc):
mapping=dict()
forlineindoc.split('\n'):
tokens=line.split()
iflen(line)<2:
continue
image_id,image_desc=tokens[0],tokens[1:]
image_id=image_id.split('.')[0]
image_desc=''.join(image_desc)
ifimage_idnotinmapping:
mapping[image_id]=list()
mapping[image_id].append(image_desc)
returnmapping
defclean_descriptions(descriptions):
table=str.maketrans('','',string.punctuation)
forkey,desc_listindescriptions.items():
foriinrange(len(desc_list)):
desc=desc_list[i]
desc=desc.split()
desc=[word.lower()forwordindesc]
desc=[w.translate(table)forwindesc]
desc=[wordforwordindesciflen(word)>1]
desc=[wordforwordindescifword.isalpha()]
desc_list[i]=''.join(desc)
returndescriptions
#savedescriptionstofile,oneperline
defsave_descriptions(descriptions,filename):
lines=list()
forkey,desc_listindescriptions.items():
fordescindesc_list:
lines.append(key+''+desc)
data='\n'.join(lines)
file=open(filename,'w')
file.write(data)
file.close()
#loadcleandescriptionsintomemory
defload_clean_descriptions(filename,dataset):
doc=load_doc(filename)
descriptions=dict()
forlineindoc.split('\n'):
tokens=line.split()
image_id,image_desc=tokens[0],tokens[1:]
ifimage_idindataset:
ifimage_idnotindescriptions:
descriptions[image_id]=list()
desc='startseq'+''.join(image_desc)+'endseq'
descriptions[image_id].append(desc)
returndescriptions
defload_set(filename):
doc=load_doc(filename)
dataset=list()
forlineindoc.split('\n'):
iflen(line)<1:
continue
identifier=line.split('.')[0]
dataset.append(identifier)
returnset(dataset)
#loadtrainingdataset
filename="dataset/Flickr8k_text/Flickr8k.token.txt"
doc=load_doc(filename)
descriptions=load_descriptions(doc)
descriptions=clean_descriptions(descriptions)
save_descriptions(descriptions,'descriptions.txt')
filename='dataset/Flickr8k_text/Flickr_8k.trainImages.txt'
train=load_set(filename)
train_descriptions=load_clean_descriptions('descriptions.txt',train)

让我们一一解释：

load_doc：获取文件的路径并返回该文件内的内容

load_descriptions：获取包含描述的文件的内容，并生成一个字典，其中以图像id为键，以描述为值列表

clean_descriptions：通过将所有字母都转换为小写字母，忽略数字和标点符号以及仅包含一个字符的单词来清理描述

save_descriptions：将描述字典作为文本文件保存到内存中

load_set：从文本文件加载图像的所有唯一标识符

load_clean_descriptions：使用上面提取的唯一标识符加载所有已清理的描述

数据预处理

接下来，我们对图像和字幕进行一些数据预处理。 图像基本上是我们的特征向量，即我们对网络的输入。 因此，我们需要先将它们转换为固定大小的向量，然后再将其传递到神经网络中。 为此，我们使用了由Google Research [3]创建的Inception V3模型(卷积神经网络)进行迁移学习。 该模型在'ImageNet'数据集[4]上进行了训练，可以对1000张图像进行图像分类，但是我们的目标不是进行分类，因此我们删除了最后一个softmax层，并为每张图像提取了2048个固定矢量，如图所示 以下：

标题文字是我们模型的输出，即我们必须预测的内容。 但是预测并不会一次全部发生，而是会逐字预测字幕。 为此，我们需要将每个单词编码为固定大小的向量(将在下一部分中完成)。 为此，我们首先需要创建两个字典，即“单词到索引”将每个单词映射到一个索引(在我们的情况下为1到1652)，以及“索引到单词”将字典将每个索引 映射到其对应的单词字典。 我们要做的最后一件事是计算在数据集中具有最大长度的描述的长度，以便我们可以填充所有其他内容以保持固定长度。 在我们的情况下，该长度等于34。

字词嵌入

如前所述，我们将每个单词映射到固定大小的向量(即200)中，我们将使用预训练的GLOVE模型。 最后，我们为词汇表中的所有1652个单词创建一个嵌入矩阵，其中为词汇表中的每个单词包含一个固定大小的向量。

#Createalistofallthetrainingcaptions
all_train_captions=[]
forkey,valintrain_descriptions.items():
forcapinval:
all_train_captions.append(cap)
#Consideronlywordswhichoccuratleast10timesinthecorpus
word_count_threshold=10
word_counts={}
nsents=0
forsentinall_train_captions:
nsents+=1
forwinsent.split(''):
word_counts[w]=word_counts.get(w,0)+1
vocab=[wforwinword_countsifword_counts[w]>=word_count_threshold]
print('Preprocessedwords{}->{}'.format(len(word_counts),len(vocab)))
ixtoword={}
wordtoix={}
ix=1
forwinvocab:
wordtoix[w]=ix
ixtoword[ix]=w
ix+=1
vocab_size=len(ixtoword)+1#oneforappended0's
#LoadGlovevectors
glove_dir='glove.6B'
embeddings_index={}
f=open(os.path.join(glove_dir,'glove.6B.200d.txt'),encoding="utf-8")
forlineinf:
values=line.split()
word=values[0]
coefs=np.asarray(values[1:],dtype='float32')
embeddings_index[word]=coefs
f.close()
embedding_dim=200
#Get200-dimdensevectorforeachofthewordsinoutvocabulary
embedding_matrix=np.zeros((vocab_size,embedding_dim))
forword,iinwordtoix.items():
embedding_vector=embeddings_index.get(word)
ifembedding_vectorisnotNone:
embedding_matrix[i]=embedding_vector

让我们接收下这段代码：

第1至5行：将所有训练图像的所有描述提取到一个列表中

第9-18行：仅选择词汇中出现次数超过10次的单词

第21–30行：创建一个要索引的单词和一个对单词词典的索引。

第33–42行：将Glove Embeddings加载到字典中，以单词作为键，将vector嵌入为值

第44–52行：使用上面加载的嵌入为词汇表中的单词创建嵌入矩阵

数据准备

这是该项目最重要的方面之一。 对于图像，我们需要使用Inception V3模型将它们转换为固定大小的矢量，如前所述。

#Belowpathcontainsalltheimages
all_images_path='dataset/Flickr8k_Dataset/Flicker8k_Dataset/'
#Createalistofallimagenamesinthedirectory
all_images=glob.glob(all_images_path+'*.jpg')
#Createalistofallthetrainingandtestingimageswiththeirfullpathnames
defcreate_list_of_images(file_path):
images_names=set(open(file_path,'r').read().strip().split('\n'))
images=[]
forimageinall_images:
ifimage[len(all_images_path):]inimage_names:
images.append(image)
returnimages
train_images_path='dataset/Flickr8k_text/Flickr_8k.trainImages.txt'
test_images_path='dataset/Flickr8k_text/Flickr_8k.testImages.txt'
train_images=create_list_of_images(train_images_path)
test_images=create_list_of_images(test_images_path)
#preprocessingtheimages
defpreprocess(image_path):
img=image.load_img(image_path,target_size=(299,299))
x=image.img_to_array(img)
x=np.expand_dims(x,axis=0)
x=preprocess_input(x)
returnx
#Loadtheinceptionv3model
model=InceptionV3(weights='imagenet')
#Createanewmodel,byremovingthelastlayer(outputlayer)fromtheinceptionv3
model_new=Model(model.input,model.layers[-2].output)
#Encodingagivenimageintoavectorofsize(2048,)
defencode(image):
image=preprocess(image)
fea_vec=model_new.predict(image)
fea_vec=np.reshape(fea_vec,fea_vec.shape[1])
returnfea_vec
encoding_train={}
forimgintrain_images:
encoding_train[img[len(all_images_path):]]=encode(img)
encoding_test={}
forimgintest_images:
encoding_test[img[len(all_images_path):]]=encode(img)
#Savethebottleneckfeaturestodisk
withopen("encoded_files/encoded_train_images.pkl","wb")asencoded_pickle:
pickle.dump(encoding_train,encoded_pickle)
withopen("encoded_files/encoded_test_images.pkl","wb")asencoded_pickle:
pickle.dump(encoding_test,encoded_pickle)
train_features=load(open("encoded_files/encoded_train_images.pkl","rb"))

1. 第1-22行：将训练和测试图像的路径加载到单独的列表中
2. 第25–53行：循环训练和测试集中的每个图像，将它们加载为固定大小，对其进行预处理，使用InceptionV3模型提取特征，最后对其进行重塑。
3. 第56–63行：将提取的特征保存到磁盘

现在，我们不会一次预测所有的标题文字，因为我们不只是将图像提供给计算机，并要求它为其生成文字。 我们要做的就是给它图像的特征向量，以及标题的第一个单词，并让它预测第二个单词。 然后我们给它给出前两个单词，并让它预测第三个单词。 让我们考虑数据集部分中给出的图像和标题“一个女孩正在进入木结构建筑”。 在这种情况下，在添加令牌“ startseq”和“ endseq”之后，以下分别是我们的输入(Xi)和输出(Yi)。

此后，我们将使用我们创建的“索引”字典来更改输入和输出中的每个词以映射索引。 在进行批处理时，我们希望所有序列的长度均等，这就是为什么要在每个序列后附加0直到它们成为最大长度(如上所述计算为34)的原因。 正如人们所看到的那样，这是大量的数据，将其立即加载到内存中是根本不可行的，为此，我们将使用一个数据生成器将其加载到小块中降低是用的内存。

#datagenerator,intendedtobeusedinacalltomodel.fit_generator()
defdata_generator(descriptions,photos,wordtoix,max_length,num_photos_per_batch):
X1,X2,y=list(),list(),list()
n=0
#loopforeveroverimages
while1:
forkey,desc_listindescriptions.items():
n+=1
#retrievethephotofeature
photo=photos[key+'.jpg']
fordescindesc_list:
#encodethesequence
seq=[wordtoix[word]forwordindesc.split('')ifwordinwordtoix]
#splitonesequenceintomultipleX,ypairs
foriinrange(1,len(seq)):
#splitintoinputandoutputpair
in_seq,out_seq=seq[:i],seq[i]
#padinputsequence
in_seq=pad_sequences([in_seq],maxlen=max_length)[0]
#encodeoutputsequence
out_seq=to_categorical([out_seq],num_classes=vocab_size)[0]
#store
X1.append(photo)
X2.append(in_seq)
y.append(out_seq)
#yieldthebatchdata
ifn==num_photos_per_batch:
yield[[array(X1),array(X2)],array(y)]
X1,X2,y=list(),list(),list()
n=0

上面的代码遍历所有图像和描述，并生成表中的数据项。 yield将使函数再次从同一行运行，因此，让我们分批加载数据

模型架构和训练

如前所述，我们的模型在每个点都有两个输入，一个输入特征图像矢量，另一个输入部分文字。 我们首先将0.5的Dropout应用于图像矢量，然后将其与256个神经元层连接。 对于部分文字，我们首先将其连接到嵌入层，并使用如上所述经过GLOVE训练的嵌入矩阵的权重。 然后，我们应用Dropout 0.5和LSTM(长期短期记忆)。 最后，我们将这两种方法结合在一起，并将它们连接到256个神经元层，最后是一个softmax层，该层预测我们词汇中每个单词的概率。 可以使用下图概括高级体系结构：

以下是训练期间选择的超参数：损失被选择为“categorical-loss entropy”，优化器为“Adam”。 该模型总共训练了30轮，但对于前20轮，批次大小和学习率分别为0.001和3，而接下来的10轮分别为0.0001和6。

inputs1=Input(shape=(2048,))
fe1=Dropout(0.5)(inputs1)
fe2=Dense(256,activation='relu')(fe1)
inputs2=Input(shape=(max_length1,))
se1=Embedding(vocab_size,embedding_dim,mask_zero=True)(inputs2)
se2=Dropout(0.5)(se1)
se3=LSTM(256)(se2)
decoder1=add([fe2,se3])
decoder2=Dense(256,activation='relu')(decoder1)
outputs=Dense(vocab_size,activation='softmax')(decoder2)
model=Model(inputs=[inputs1,inputs2],outputs=outputs)
model.layers[2].set_weights([embedding_matrix])
model.layers[2].trainable=False
model.compile(loss='categorical_crossentropy',optimizer='adam')
epochs=20
number_pics_per_batch=3
steps=len(train_descriptions)//number_pics_per_batch
generator=data_generator(train_descriptions,train_features,wordtoix,max_length1,number_pics_per_batch)
history=model.fit_generator(generator,epochs=20,steps_per_epoch=steps,verbose=1)
model.optimizer.lr=0.0001
epochs=10
number_pics_per_batch=6
steps=len(train_descriptions)//number_pics_per_batch
generator=data_generator(train_descriptions,train_features,wordtoix,max_length1,number_pics_per_batch)
history1=model.fit_generator(generator,epochs=10,steps_per_epoch=steps,verbose=1)
model.save('saved_model/model_'+str(30)+'.h5')

让我们来解释一下代码：

第1-11行：定义模型架构

第13–14行：将嵌入层的权重设置为上面创建的嵌入矩阵，并且还设置trainable = False，因此该层将不再受任何训练

第16–33行：如上所述，使用超参数在两个单独的间隔中训练模型

推理

下面显示了前20轮的训练损失，然后是接下来的10轮的训练损失：

为了进行推断，我们编写了一个函数，该函数根据我们的模型(即贪心)将下一个单词预测为具有最大概率的单词

defgreedySearch(photo):
in_text='startseq'
foriinrange(max_length1):
sequence=[wordtoix[w]forwinin_text.split()ifwinwordtoix]
sequence=pad_sequences([sequence],maxlen=max_length1)
yhat=model.predict([photo,sequence],verbose=0)
yhat=np.argmax(yhat)
word=ixtoword[yhat]
in_text+=''+word
ifword=='endseq':
break
final=in_text.split()
final=final[1:-1]
final=''.join(final)
returnfinal
z=1
pic=list(encoding_test.keys())[999]
image=encoding_test[pic].reshape((1,2048))
x=plt.imread(images+pic)
plt.imshow(x)
plt.show()
print("Greedy:",greedySearch(image))

效果还不错