ELMo模型计算详解

写在前面

本文记录本人在学习ELMo模型时的记录，具体为解析了在Google的开源实现中给出的源码中，论文中各个模块的输入输出维度变化。希望可以对读者学习ELMo模型时有些帮助。

另外，本章图片内容参考了b站up主自然卷小蛮的视频，在此声明(https://www.bilibili.com/video/BV12L411T7Vh)

ELMo（Embeddings from Language Models）是一个深度学习框架，用于生成上下文感知的词嵌入。这个模型由Allen Institute for Artificial Intelligence的研究人员在2018年开发，并在论文“Deep contextualized word representations”中提出。ELMo的出现标志着自然语言处理（NLP）技术在理解语言上下文和词义的深度方面迈出了重要的一步。

在ELMo之前，词向量技术如Word2Vec和GloVe已经能够捕获一定的语义信息，并在各种NLP任务中取得了显著的成功。然而，这些模型生成的是静态的词嵌入，即每个词在任何上下文中的表示都是固定不变的。这种静态表示无法解决词义消歧问题，也无法充分捕捉语言的复杂性和动态性。ELMo模型的出现旨在解决这一问题。

模型方法

ELMo 模型的网络的整体结构如下图所示。 输入是一个句子，将句子输入到 Character-aware highway encoder 字符编码层，然后经过两层双向 LSTM ，最后通过 softmax 层，然后得到预测的单词结果或者进行损失计算。

ELMo模型输入

ELMo模型的输入是一个句子，例如"She opened her book."。由于在Character-aware highway encoder中我们会详细处理单词并提取其特征，所以这里我们将句子作为ELMo模型的输入传入到Character-aware highway encoder层中。

Character-aware highway encoder

character-CNN

我们首先来看 Character-aware highway encoder 层，总体结构如图下所示。

Character-CNN层的输入是单个单词的字符序列。我们会对每个单词进行处理得到固定维度的向量，然后使用CNN卷积进行特征提取。下面进行依次介绍。char-CNN展开后的模型细节如图所示。

首先，每个字符通过字符嵌入（character embeddings）被转换为固定维度的向量。设字符总数为$n$，字符嵌入的维度为$d$，单词最多由$L$个字符组成，句子最多有$k$个单词，则输入的每个单词将会转化成矩阵$V_{char}^{new}\in {\mathbb{R}}^{L\times d}$。具体来说，将每个字符用one-hot的方式进行表示，每个字符就是 $n\times 1$维的向量，我们通过线性变换，将每个字符的维度从$n$压缩为$d$，然后限定单词的最大字符数，即可把每个单词的维度固定为 $d\times L$，即
$$V_{char}^{new}=V_{char}^{one-hot}{W}_c+b_c$$
其中 $W_c\in {\mathbb{R}}^{n\times d}$ 是对应的权重矩阵，$b_c\in {\mathbb{R}}^{d\times 1}$ 为权重矩阵$W_c$对应的置偏值，$V_{char}^{one-hot}\in {\mathbb{R}}^{d\times n}$为字符的one-hot向量，$V_{char}^{new}$为$V_{char}^{one-hot}$从维度$n\times 1$ 映射为维度 $d\times 1$后的字符的向量，通常$n>d$。

这种字符嵌入的方式与Word2Vec中的两种词嵌入方式不同，Word2Vec中的两种方法都是把 单词 转换为one-hot向量，而在ELMo的输入中，将 字符 转换为one-hot向量，使用矩阵表示单词，这样可以从字符层面挖掘单词的特征。

通过上面的字符嵌入，我们就可以用字符的向量来构建单词的向量。在ELMo中，规定一个单词的最大字符个数不超过$L$，超过$L$时会进行截断，不足$L$时会使用特殊字符的字符编码进行末尾填充。这样我们可以用$V_{word}\in {\mathbb{R}}^{d\times L}$表示一个单词，即
$$V_{word}=V_t=[V_{char1}^{new},V_{char2}^{new},\dots ,V_{charL}^{new}]=[V_{char1}^{one-hot},V_{char2}^{one-hot},\dots ,V_{charL}^{one-hot}]W_c+b_c$$
$$V_{word}=\left[\begin{array}{cccc}{v}_{1,1}^{word}& v_{1,2}^{word}& \dots & v_{1,L}^{word}\\ v_{2,1}^{word}& v_{2,2}^{word}& \dots & v_{2,L}^{word}\\ \dots & \dots & \dots & \dots \\ v_{d,1}^{word}& v_{d,2}^{word}& \dots & v_{d,L}^{word}\end{array}\right]$$
其中，$V_{chari}^{new}$是单词中第$i$个字符的嵌入向量。这样我们就完成了character-embedding的过程。$V_{word}=V_t$ 表示当前输入的第$t$个单词的单词矩阵。

下面介绍AllenNLP中实现的ELMo，character-embedding处理的方式。

在AllenNLP的ELMo的character-embedding中，利用Unicode 字符级对单词的每个字符进行编码。在Unicode 字符集中 $0-255$共有$256$个字符，加上（单词的开始）、（单词的结束）、 （句子的开始）、（句子的结束）、（单词补齐符）和（句子补齐符）这$6$个特殊字符，一共有$262$个字符，构成了字符集表示中的字符表，即$n=262$。ELMo的思想是给每个字符生成一个固定维度地随机向量，在AllenNLP的ELMo的character-embedding实现中，这 $262$ 个字符向量会被固定为维度为 $16\times 1$（字符嵌入维度为$16$，$d=16$）的向量，采用的方法是将$262$ 个字符以one-hot向量的形式进行表示，随后通过线性变换的形式转为换固定维度为 $16\times 1$的向量。

在AllenNLP的ELMo实现中，$L=50$、$n=262$、$d=16$，我们以单词 opened 为例子，首先将其分解成 ‘o’,‘p’,‘e’,‘n’,‘e’,‘d’，共$6$个字符，分别使用相应的字符向量表示，由于单词向量使用$50$个字符向量固定，后面$44$个 字符均使用填充，这样我们就将其固定成字符数量大小为 $50$ 。于是我们就可以完成 opened 这个单词的编码。此时单词的维度$ 16 \times 50$。这里由于AllenNLP中的嵌入维度较大不方便展示，简单的嵌入例子参考章节ELMo-demo简单的ELMo例子中的字符嵌入过程。

CNN

对于一个句子经过 character-embedding 之后，就会进入 CNN 层，CNN 的核心是使用卷积神经网络。我们考虑一个单词，其字符表示为$v_{word}$，$v_{word}$是一个 $d\times L$的矩阵$d$是每个字符的嵌入维度，$L$是单词的最大长度，则我们可以定义卷积操作：
对于给定卷积核 $K$，
$$K=[K_1,K_2,\dots ,K_f],K_j=\left[\begin{array}{cccc}{k}_{1,1,j}& k_{1,2,j}& \dots & k_{1,w,j}\\ k_{2,1,j}& k_{2,2,j}& \dots & k_{2,w,j}\\ \dots & \dots & \dots & \dots \\ k_{d,1,j}& k_{d,2,j}& \dots & k_{d,w,j}\end{array}\right]$$
其尺寸为 $d\times w\times f$，其中：

• $K$表示卷积核矩阵集合（张量），$K_j$表示卷积核矩阵，$k_{d,w,j}$表示卷积核矩阵中各个位置的元素值。
• $d$是卷积核覆盖的字符嵌入维度（与输入维度相匹配），
• $w$是卷积核的宽度（覆盖的字符数） ，
• $f$是该卷积核输出的特征数量（或称为过滤器数量）。
• $j=1,2,\dots ,f$。

卷积操作的输出$c$对于每个特征图$j$的每个位置$i$在单词长度方向上可以表示为：
$$c_{i,j}=\sum _{m=1}^d\sum _{n=1}^w{v}_{m,n}^{word}{k}_{m,n,j}+b_{cnn}^j$$
这里，$b_{CNN}^j\in \text{R}$是与过滤器 $K_j$关联的偏置项。输出的维度$c$为
$(L-w+1)\times f$，假设没有填充（padding）和步长（stride）为 $1$。

在卷积后进行最大池化操作，最大池化在每个特征图上独立进行，选取每个特征图中的最大值。对于每个过滤器$K_j$，池化操作可表示为
$${\hat{c}}_j=\max (c_{1,j},c_{2,j},\dots ,c_{L-w+1,j}),(j=1,2,\dots ,f)$$
最终，池化后的所有特征${\hat{c}}_j$被拼接起来形成一个特征向量 $y$，用作单词的嵌入表示：
$$y_t=({\hat{c}}_1,{\hat{c}}_2,\dots ,{\hat{c}}_F)$$
其中$F$是过滤器的总数量（每个卷积核的过滤器相加求和得到总的过滤器数量），则$Y=[y_1,y_2,\dots ,y_t,\dots ,y_n]$为$F\times n$维向量。随后，我们将一个个的单词向量$y_t$传入 highway-connection层。

在AllenNLP的ELMo的character-CNN中，包含了 7 种过滤器，分别是 16 $\times$ 1 $\times$ 32、16 $\times$ 2 $\times$ 32、16 $\times$ 3 $\times$ 64、16 $\times$ 4 $\times$ 128、16 $\times$ 5 $\times$ 256、16 $\times$ 6 $\times$ 512、16 $\times$ 7 $\times$ 1024。过滤器尺寸依次为32、32、64、128、256、512、1024。

通过卷积层后通过池化层，顺着 $1$ 这一维度进行取最大（MaxPool）也就是将 16 行（在图中就是纵向压缩）通过取最大压缩成 $1$ 行，也就是将 $16\times 50$ 通过池化（取最大）变成 $1\times 50$。我们将得到一个个的 vector 顺着 $1$ 这一维度进行拼接，可以得到一个 $1\times 2048$ 的 vector。

highway-connection

接下来是两层的 highway-connection，Highway 网络层的输出是经过门控调节的特征表示，这些表示为后续层（如双向LSTM层）提供了更加精细调整的输入，对于每个时间步的输入是$y_t$。输出的特点包括：

• 保留与变换：Highway层通过两个主要的门控机制实现信息的保留与变换——一个是变换门（T门），另一个是携带门（C门）。变换门控制有多少当前层的原始信息需要被变换，而携带门控制有多少原始信息需要不加修改地传递到下一层。
• 门控特征表示：因此，Highway层的输出是原始输入特征的一个门控版本，其中一部分特征被保留并直接传递，而另一部分特征经过变换以提供额外的信息或调整。

变换门：
$$T=\sigma (W_T{y}_t+b_T)$$

其中 $\sigma$ 是sigmoid激活函数，确保输出在0和1之间，表示每个特征的转换程度。$y_t\in {\mathbb{R}}^{p\times 1}$ 是输入特征，$W_T\in {\mathbb{R}}^{p\times p}$和 $b_T\in {\mathbb{R}}^{p\times 1}$ 是变换门的权重和偏置，$T\in {\mathbb{R}}^{p\times 1}$。

携带门：
$$C=1-T$$
携带门的计算很简单，就是1减去变换门的输出，确保变换和携带的总和为1，这样可以保持信息的完整性，$C\in {\mathbb{R}}^{p\times 1}$。

输出：
$$z_t=T\odot g(W_H{y}_t+b_H)+C\odot y_t$$

其中，$y_t\in {\mathbb{R}}^{p\times 1}$ 是输入特征，$W_H\in {\mathbb{R}}^{p\times p}$是变换操作的权重，$b_H\in {\mathbb{R}}^{p\times 1}$为对应的置偏值，$g(W_H{y}_t+b_H)$
是对输入 $y_t$ 的非线性变换（通常是ReLU激活函数），
$T$是变换门的激活， $C$是携带门的激活，而 $z_t\in {\mathbb{R}}^{p\times 1}$ 是该 Highway 层的输出，$\odot$ 是点乘。

通过这样的设计，Highway 层使得网络能够自适应地调节信息的流动，既能保留对后续处理有用的重要信息，也能对输入特征进行必要的变换，这对于深层次的语义理解尤为重要。

在AllenNLP的ELMo中，进行运算完highway-connection后我们得到结果还是$1\times 2048$ 的 vector。最后的 MLP 层就是一层线性映射，将维度为 $2048$ 的 vector 压缩成 $512$ 维的 vector。

MLP

MLP在此处就是对highway-connection得到的特征进行压缩，然后输入给双向LSTM，具体来说就是一个简单的线性映射，即
$$u_t=W_{char-cnn-mlp}{z}_t+b_{char-cnn-mlp}$$
其中，$z_t\in {\mathbb{R}}^{p\times 1}$是输入特征。假设需要映射到的维度大小是$m$，则$u_t\in {\mathbb{R}}^{m\times 1}$，$W_{char-cnn-mlp}\in {\mathbb{R}}^{m\times p}$和$b_{char-cnn-mlp}\in {\mathbb{R}}^{m\times 1}$是该全连接层的权重矩阵和置偏。

在AllenNLP的ELMo的此处的MLP中，使用 MLP 对 1 $\times$ 2048 的 vector 进行处理，得到 1 $\times$ 2048 的 vector 作为输入进入双向 LSTM 层。

bidrectional LSTM

接下来就是 ELMo 的核心，两层双向 LSTM。双层双向LSTM得输入是上层输出的单词向量得集合，即
$$U=(u_1,u_2,\dots ,u_n)$$
其中 $u_t\in {\mathbb{R}}^{m\times 1}$ 表示当前单词的向量表示（或者当前时刻单词的向量表示），$n$表示一共有多少个单词（有多少个时刻），且 $U\in {\mathbb{R}}^{m\times n}$。

双向LSTM结构包括前向和后向两个LSTM网络，能够捕获上下文信息。我们从LSTM再到双向LSTM对其进行描述，具体如下一小结。

LSTM

我们先简单回忆LSTM的结构与计算方法。LSTM的模型结构如图\ref{ELMo-LSTM}所示。$u_t$ 是时间步 $t$ 的输入，维度为 $m\times 1$ ，$h_t$表示当前时刻隐藏层输入，$c_t$表示当前时刻当前状态单元$W_f$， $b_f$，$W_i$，$b_i$，$W_C$，$b_C$，$W_o$，$b_o$分别为LSTM层各个门和模块的权重矩阵和置偏，$h_0$、$c_0$通常初始化为$0$向量，权重矩阵和置偏通常随机初始化。

遗忘门（Forget Gate）
遗忘门的计算公式为
$$f_t=\sigma (W_f\cdot [h_{t-1},u_t]+b_f)$$
其中，$W_f$ 是权重矩阵，维度为 $h\times (h+m)$，$b_f$ 是偏置，维度为 $h\times 1$，$h$是隐藏层维度，$\sigma$ 是sigmoid函数。

输入门（Input Gate）
输入门的计算公式为
$$i_t=\sigma (W_i\cdot [h_{t-1},u_t]+b_i)$$
$${\tilde{c}}_t=\tanh (W_C\cdot [h_{t-1},u_t]+b_C)$$
$W_i$ 和 $W_C$ 是权重矩阵，维度为 $h\times (h+m)$，$b_i$ 和 $b_C$ 是偏置，维度为 $h\times 1$。

单元状态更新
单元状态更新计算公式为
$$c_t=f_t\odot c_{t-1}+i_t\odot {\tilde{c}}_t$$
$c_t$ 和 $c_{t-1}$ 的维度为 $h\times 1$。

输出门（Output Gate）
输出门的计算公式为
$$o_t=\sigma (W_o\cdot [h_{t-1},u_t]+b_o)$$
$$h_t=o_t\odot \tanh (c_t)$$
$W_o$ 是权重矩阵，维度为 $h\times (h+m)$，$b_o$ 是偏置，维度为 $h\times 1$。

以上就是LSTM模块的计算，理解了单个LSTM的计算我们就可以进一步计算双向LSTM和双层双向LSTM。为了方便表示，我们将计算过程封装为
$$h_t=\text{LSTM}(u_t,h_{t-1})$$

双向结构

双向LSTM的模型结构如图下所示，在ELMo模型的bidLSTM中的LSTM模块的输入 $u_t$ 是时间步 $t$ 的字符嵌入或词嵌入，维度为 $m\times 1$ ，${\overrightarrow{h}}_t$表示当前时刻正向LSTM隐藏层输入，${\overleftarrow{h}}_t$ 表示当前时刻反向LSTM隐藏层输入，其维度为 $m\times 1$，通常正向的隐藏层${\overrightarrow{h}}_0$和反向的隐藏层${\overleftarrow{h}}_t$均随机初始化或者初始化为值全为$0$的向量或者值全为$1$的向量。$u_t$通过与${\overrightarrow{h}}_{t-1}$拼起来构成LSTM的输入，传入正向的LSTM，进行LSTM中的步骤计算，输出${\overrightarrow{h}}_t$传入后一个LSTM模块，不断迭代，将每个时间步的隐藏层输出${\overrightarrow{h}}_t$序列作为该正向LSTM模块的输出。同理，$u_t$通过与${\overleftarrow{h}}_{t+1}$拼起来构成LSTM的输入，传入正向的LSTM，进行LSTM中的步骤计算，输出${\overleftarrow{h}}_t$传入前一个LSTM模块，不断迭代，将每个时间步的隐藏层输出${\overleftarrow{h}}_t$序列作为该反向LSTM模块的输出。

对于每一个$u_t$，正向LSTM计算表示为
$${\overrightarrow{h}}_t={\text{LSTM}}_{+}({\overrightarrow{h}}_{t-1},u_t)$$
其中 $\overrightarrow{h_t}$、$\overrightarrow{h_{t-1}}\in {\mathbb{R}}^{m\times 1}$，${\text{LSTM}}_{+}$表示正向的LSTM运算。

对于每一个$u_t$，反向LSTM计算表示为
$${\overleftarrow{h}}_t={\text{LSTM}}_{-}({\overleftarrow{h}}_{t+1},u_t)$$
其中 $\overleftarrow{h_t}$、$\overleftarrow{h_{t-1}}\in {\mathbb{R}}^{m\times 1}$，${\text{LSTM}}_{-}$表示正向的LSTM运算。

于是有

• 前向LSTM从左到右处理输入序列，生成隐藏状态序列 ${\overrightarrow{h}}_1,{\overrightarrow{h}}_2,\dots ,{\overrightarrow{h}}_n$.
• 后向LSTM从右到左处理输入序列，生成隐藏状态序列 ${\overleftarrow{h}}_1,{\overleftarrow{h}}_2,\dots ,{\overleftarrow{h}}_n$.

我们将结果记为
$$\overrightarrow{H}=[{\overrightarrow{h}}_1,{\overrightarrow{h}}_2,\dots ,{\overrightarrow{h}}_n]$$
$$\overleftarrow{H}=[{\overleftarrow{h}}_1,{\overleftarrow{h}}_2,\dots ,{\overleftarrow{h}}_n]$$
其中${\overleftarrow{h}}_t$、${\overrightarrow{h}}_t\in {\mathbb{R}}^{m\times 1}$，$\overleftarrow{H}$、$\overrightarrow{H}\in {\mathbb{R}}^{m\times n}$

双层双向LSTM

在ELMo中并不是简单地设置一层双向LSTM，而是使用两层。具体计算方式是将第一层双向LSTM中得到的正向LSTM的隐藏层向量传入第二层正向的LSTM，将第一层的双向LSTM中的得到的反向LSTM的隐藏层向量传入第二层反向的LSTM。ELMo中的双层双向LSTM如图\ref{ELMo-double-ward-Bid-LSTM}所示。

与上面计算第一层的双向LSTM类似，我们用公式进行描述对于每一个${\overrightarrow{h}}_t$，正向LSTM计算表示为
$${\overrightarrow{h}}_t^{new}={\text{LSTM}}_{+}({\overrightarrow{h}}_{t-1}^{new},{\overrightarrow{h}}_t)$$
其中 ${\overrightarrow{h_t}}^{new}$、$\overrightarrow{h_{t-1}^{new}}\in {\mathbb{R}}^{m\times 1}$，${\text{LSTM}}_{+}$表示正向的LSTM运算。

对于每一个${\overleftarrow{h}}_t$，反向LSTM计算表示为
$${\overleftarrow{h}}_t^{new}={\text{LSTM}}_{-}({\overleftarrow{h}}_{t+1}^{new},{\overleftarrow{h}}_t)$$
其中 ${\overleftarrow{h_t}}^{new}$、${\overleftarrow{h_t}}^{new}\in {\mathbb{R}}^{m\times 1}$，${\text{LSTM}}_{-}$表示正向的LSTM运算。

于是有

• 前向LSTM从左到右处理输入序列将上面生成的第一层隐藏状态传递给下一层，生成隐藏状态序列 ${\overrightarrow{h}}_1^{new},{\overrightarrow{h}}_2^{new},\dots ,{\overrightarrow{h}}_n^{new}$.
• 后向LSTM从右到左处理输入序列将上面生成的第一层隐藏状态传递给下一层，生成隐藏状态序列 ${\overleftarrow{h}}_1^{new},{\overleftarrow{h}}_2^{new},\dots ,{\overleftarrow{h}}_n^{new}$.

我们将结果记为
$${\overrightarrow{H}}^{new}=[{\overrightarrow{h}}_1^{new},{\overrightarrow{h}}_2^{new},\dots ,{\overrightarrow{h}}_n^{new}]$$
$${\overleftarrow{H}}^{new}=[{\overleftarrow{h}}_1^{new},{\overleftarrow{h}}_2^{new},\dots ,{\overleftarrow{h}}_n^{new}]$$
其中${\overleftarrow{h}}_t^{new}$、${\overrightarrow{h}}_t^{new}\in {\mathbb{R}}^{m\times 1}$，${\overleftarrow{H}}^{new}$、${\overrightarrow{H}}^{new}\in {\mathbb{R}}^{m\times n}$

bid-LSTM输出

在通常情况下，最终输出 $S=[\overrightarrow{s_1},\overrightarrow{s_2},\dots ,\overrightarrow{s_{2m}}]$ 是对前面的双层双向LSTM进行了如下操作：
对于每个时间步，将两层得到的正向LSTM的隐藏层输出与反向LSTM的隐藏层输出相加，即
$${\overrightarrow{h}}_t+{\overrightarrow{h}}_t^{new},{\overleftarrow{h}}_t+{\overleftarrow{h}}_t^{new}$$
然后再将得到的结果拼成一个更长的向量得到结果，即
$$\overrightarrow{s_t}=[{\overrightarrow{h}}_t+{\overrightarrow{h}}_t^{new};{\overleftarrow{h}}_t+{\overleftarrow{h}}_t^{new}]$$
如果每个方向的隐藏状态维度为 $m$，则 $\overrightarrow{s_t}$ 的维度为 $2m\times 1$。

于是我们得到
$$S=[\overrightarrow{s_1},\overrightarrow{s_2},\dots ,\overrightarrow{s_{2m}}]$$
其中$\overrightarrow{s_t}\in {\mathbb{R}}^{2m\times 1}$， $S\in {\mathbb{R}}^{2m\times n}$

MLP and Softmax

为了得到对应的单词，我们通过一层线性映射，将单词向量表示转换为高维的表示，然后通过Softmax得到每个时刻$t$单词的概率分布，从而得到要预测的单词。即对于每一个时间步
$$\overrightarrow{q_t}=W_s\overrightarrow{s_t}+b_s$$
其中，$\overrightarrow{q_t}\in {\mathbb{R}}^{V\times 1}$为映射后的向量、 $W_s\in {\mathbb{R}}^{V\times 2h}$为映射的权重矩阵、$b_s\in {\mathbb{R}}^{V\times 1}$为对应的置偏，$V$为单词表的维度。

写成矩阵的形式为
$$Q=W_{s}S+b_s$$
其中，$Q=[\overrightarrow{q_1},\overrightarrow{q_2},\dots ,\overrightarrow{q_n}]\in {\mathbb{R}}^{V\times n}$，$\overrightarrow{q_t}\in {\mathbb{R}}^{V\times 1}$，$S\in {\mathbb{R}}^{2m\times n}$，$\overrightarrow{s_t}\in {\mathbb{R}}^{2m\times 1}$。

随后我们使用Softmax将向量$\overrightarrow{q_t}=[q_1,q_2,\dots ,q_V{]}^T$转换为概率分布向量$\overrightarrow{p_i}$，即
$$\overrightarrow{p_i}=\text{Softmax}(\overrightarrow{q_i})=\frac{\exp (q_i)}{\sum _{k=1}^V\exp (q_k)}$$
其中，$\overrightarrow{q_t}\in {\mathbb{R}}^{V\times 1}$为映射后的向量、$\overrightarrow{p_t}\in {\mathbb{R}}^{V\times 1}$为转换为概率分布后的向量。

写成矩阵的形式为
$$P=(\overrightarrow{p_1},\overrightarrow{p_2},\dots ,\overrightarrow{p_n})$$
其中 $\overrightarrow{p_t}\in {\mathbb{R}}^{V\times 1}$ 为每个单词对应位置的词向量表示的概率分布，$P\in {\mathbb{R}}^{V\times n}$为整个句子的矩阵向量。

ELMo模型输出

实际上MLP and Softmax层输出的概率分布矩阵实际上就是ELMo模型的输出，即上下文感知的表示。通过这个概率分布，我们可以从词汇表中查出需要预测的单词。

损失函数

在计算得到bid-LSTM的结果之后，我们将得到的词向量表示映射到整个单词集合，然后使用Softmax计算概率分布，然后使用交叉熵来计算ELMo模型的损失。

在此处的Softmax运算之前，由于我们的在双向LSTM中的输出维度是$2h$，我们要将其映射为词汇表的维度$V$，随后我们使用softmax将向量q转换为概率分布，最后使用交叉熵损失来计算ELMo模型的损失，即正确的标签为one-hot向量，然后与预测的向量一起进行交叉熵损失计算，得到每一时刻的损失，即
$${\text{Loss}}_t=-\sum _{i=1}^{V}ta{g}_i\log (p_i)$$
其中，$p\in {\mathbb{R}}^{V\times 1}$ 为预测概率分布向量，$tag\in {\mathbb{R}}^{V\times 1}$为正确的标签，${\text{Loss}}_t$表示在$t$时刻时得到的损失。

最后再将所有的损失进行求均值得到总的损失，即
$$\text{Loss}=\frac{1}{T}\sum _{i=1}^T{\text{Loss}}_i$$
其中，$T$为总的时刻数，${\text{Loss}}_i$为$t$时刻的损失。