春节网页设计素材网站,企查查企业在线查询,搭建好ftp服务器 如何通过网站访问,网站详情页设计首先我们需要明确 c t c l o s s ctcloss ctcloss是用来做什么的。比如说要生成的目标字符串长度为 l l l#xff0c;而这个字符串包含 s s s个字符#xff0c;字符串允许的最大长度为 L L L#xff0c;这里认为一个位置是一个时间步#xff0c;就是一拍#xff0c;记为 T…首先我们需要明确 c t c l o s s ctcloss ctcloss是用来做什么的。比如说要生成的目标字符串长度为 l l l而这个字符串包含 s s s个字符字符串允许的最大长度为 L L L这里认为一个位置是一个时间步就是一拍记为 T T T。 对于这个允许最大长度需要做出一些解释定义一个生成字符串的规则因为训练的时候这个标签的长度是不一样的所以我们需要引入空格来生成字符串那么相应的关于空格定义以下两条规则
空格与空格之间的字符串是可以去掉重复字母的使用空格间隔的两个部分串不能去重比如说这个串长成cc cc在运用上述两条规则之后应该变成c c
举例来说对于目标生成串如果是 C A T CAT CAT的话那么在时间拍为 5 5 5拍的情况下他有这以下 28 28 28条路径可以生成 C A T CAT CAT 注上述图片引自这里博主对这篇文章加以致谢还好有这个文章让我对 c t c l o s s ctcloss ctcloss有了初步的认识。
因此首先拿在手里的是一个随机矩阵为 y y y这个矩阵的形状是 [ k , T ] [k,T] [k,T]其中 y [ i , j ] y[i,j] y[i,j]表示的是在第 j j j个时间步该字符为 i i i的概率而我们需要做的是训练这个 y y y矩阵让他最终产生指定字符串的概率 p p p最大所以设置 − l n ( p ) -ln(p) −ln(p)为损失函数目标就是让这个损失函数最小。 那么应该怎么做呢你可以枚举出这全部 28 28 28条路径的概率 l i k e t h i s like\space this like this然后把他们相加之后求损失和。 但是我知道你一定不想这么做。所以呢我们需要使用一种更加简洁的方法来求这个概率咋做呢这里就要放上这张过程图了。
首先对字符串进行了插入空格的操作我一开始的时候不给他插入空格不行必须得考虑每一步能不能取到空格并且状态转移的时候还要考虑从第几个空格转移过来非常麻烦不如直接插入空格。接下来使用动态规划的方法来代替暴力搜索分析 t t t时刻由 t − 1 t-1 t−1时刻字符的状态转移方程
在 t t t时刻能取到 s s s字符那么这个字符可以由 t − 1 t-1 t−1时刻的 s s s字符转移过来两个一样的字符消去就行了呗。由 s − 1 s-1 s−1字符转移过来 就是 _ C _ A _ T _ \_C\_A\_T\_ _C_A_T_的 T T T接在 _ \_ _后面的情况。从第 s − 2 s-2 s−2个字符转移过来这个时候第 s s s个字符和第 s − 2 s-2 s−2个字符必须不能相同否则的话就是 _ C _ A _ A _ T _ \_C\_A\_A\_T\_ _C_A_A_T_的两个 A A A越过中间的空格连在一起这不铁定消去了。
所以状态转移使用如下的方法实现
alpha[s, t] alpha[s, t - 1]
if s - 1 0:alpha[s, t] alpha[s - 1, t - 1]
if s - 2 0 and blank_label[s] ! 0 and blank_label[s] ! blank_label[s - 2]:alpha[s, t] alpha[s - 2, t - 1]
alpha[s, t] * y[map_dict[blank_label[s]], t]但是你一定会问弄这个动态规划矩阵有个锤子用我们来看看 对于 a l p h a alpha alpha矩阵当中的任意一个元素来说可以得到以下的表达式其中 l l l是任意一个可能产生字符串的路径 π \pi π是全部路径 l t l_t lt代表这个路径上在第 t t t拍上的字符 P P P为概率。 a l p h a [ i , t ] P ( l t ) ∑ l ∈ π ∏ t ′ 1 t − 1 P ( l t ′ ) alpha[i,t] P(l_t)\sum_{l\in \pi} \prod_{t1}^{t-1} P(l_{t}) alpha[i,t]P(lt)l∈π∑t′1∏t−1P(lt′) 那么如果求出后向传播的矩阵 b e t a beta beta b e t a [ i , t ] P ( l t ) ∑ l ∈ π ∏ t ′ t 1 T P ( l t ′ ) beta[i,t] P(l_t)\sum_{l\in \pi} \prod_{tt1}^{T} P(l_{t}) beta[i,t]P(lt)l∈π∑t′t1∏TP(lt′) 就能得到矩阵 a l p h a [ i , t ] ∗ b e t a [ i , t ] P ( l t ) ∑ l ∈ π ∏ t ′ 1 T P ( l t ′ ) alpha[i,t]*beta[i,t] P(l_t)\sum_{l\in \pi} \prod_{t1}^{T} P(l_{t}) alpha[i,t]∗beta[i,t]P(lt)l∈π∑t′1∏TP(lt′) 所以我非常想求的总概率 p ∑ l ∈ π ∏ t ′ 1 T P ( l t ′ ) p\sum_{l\in \pi} \prod_{t1}^{T} P(l_{t}) p∑l∈π∏t′1TP(lt′)就可以使用 a l p h a [ i , t ] ∗ b e t a [ i , t ] P ( l t ) \frac{alpha[i,t]*beta[i,t]}{P(l_t)} P(lt)alpha[i,t]∗beta[i,t]来表示。 公式推导鸣谢这里 注这只是我大概的理解不能十分完备的使用原文章中的符号 接下来就到了非常鸡冻人心的训练过程差点没给我训练死了。因为改了一天这个梯度公式并且我体会了什么是梯度消失 s o f t m a x softmax softmax的作用接下来将详细记录我训练的这个过程应该只是我记得的了其中非常感谢参考文献中文章的帮助尤其是在晚上八点还是没有结果的时候看到的这篇文章但是当时通过死亡调试梯度矩阵已经反应过来是梯度问题了hh。首先先声明一下我不能完全保证我的梯度求解没有问题但是的确训练出了结果并且参考多篇博客梯度的结果全都不一样因此我只能找到一个我认为最合理的梯度来进行梯度下降。 那么再来捋一下思路首先要最小化 − l n ( p ) -ln(p) −ln(p)而前面已经求出 p a l p h a [ i , t ] ∗ b e t a [ i , t ] P ( l t ) p\frac{alpha[i,t]*beta[i,t]}{P(l_t)} pP(lt)alpha[i,t]∗beta[i,t]这里将 P ( l t ) P(l_t) P(lt)换成 y k t y_{k}^{t} ykt来表示就是在 t t t时刻的第 k k k个字符的概率。我们想对 y y y求偏导但有一个 b u g bug bug就是 y y y他不一定每一列的和都是 1 1 1所以需要对他进行 s o f t m a x softmax softmax操作因此用 x k t x_{k}^{t} xkt代表经过 s o f t m a x softmax softmax之后的 y k t y_{k}^{t} ykt。分析一下 y y y经过所有变换得到 p p p的过程 y ∼ s o f t m a x ∼ a l p h a b e t a ∼ p y\sim softmax \sim alphabeta \sim p y∼softmax∼alphabeta∼p。需要求的梯度经过以上分析可以表示成为 ∂ ( − l n p ) ∂ y k t − 1 p ∂ p ∂ x k t ∂ x k t ∂ y k t \begin{align} \frac{\partial (-lnp)}{\partial y_{k}^{t}} -\frac{1}{p}\frac{\partial p}{\partial x_{k}^{t}}\frac{\partial x_{k}^{t}}{\partial y_{k}^{t}} \end{align} ∂ykt∂(−lnp)−p1∂xkt∂p∂ykt∂xkt 前面已经知道 p a l p h a [ i , t ] ∗ b e t a [ i , t ] x k t p\frac{alpha[i,t]*beta[i,t]}{x_{k}^{t}} pxktalpha[i,t]∗beta[i,t]在这个公式当中 a l p h a 、 b e t a alpha、beta alpha、beta与 x k t x_{k}^{t} xkt并不是完全没有关系的他们可以表示成 c o n s 1 ∗ x k t cons1*x_{k}^{t} cons1∗xkt的形式其中 c o n s 1 cons1 cons1是到达 x k t x_{k}^{t} xkt字符之前的所有可能字符概率乘积的和 c o n s 2 cons2 cons2同理值得注意的是我们的假定是字符的概率是可以相乘的也就是完全独立的因此 c o n s 1 cons1 cons1和 c o n s 2 cons2 cons2对于 x k t x_k^t xkt来说是常数。所以 p p p应该化简为 c o n s 1 ∗ c o n s 2 ∗ x k t cons1*cons2*x_{k}^{t} cons1∗cons2∗xkt其中 c o n s 1 a l p h a x k t , c o n s 2 b e t a x k t cons1\frac{alpha}{x_{k}^{t}},cons2 \frac{beta}{x_{k}^{t}} cons1xktalpha,cons2xktbeta所以 ∂ p ∂ x k t a l p h a x k t b e t a x k t \begin{align} \frac{\partial p}{\partial x_{k}^{t}}\frac{alpha}{x_{k}^{t}}\frac{beta}{x_{k}^{t}} \end{align} ∂xkt∂pxktalphaxktbeta 由于 x k t s o f t m a x ( y k t ) x_{k}^{t}softmax(y_{k}^{t}) xktsoftmax(ykt)即 x k t e y k t ∑ j 1 s e y j t x_{k}^{t}\frac{e^{y_{k}^{t}}}{\sum_{j1}^{s}e^{y_{j}^{t}}} xkt∑j1seyjteykt所以有 ∂ x k t ∂ y k t e y k t ∗ ∑ j 1 s e y j t − ( e y k t ) 2 ( ∑ j 1 s e y j t ) 2 x k t − ( x k t ) 2 \begin{align} \frac{\partial x_{k}^{t}}{\partial y_{k}^{t}} \frac{e^{y_{k}^{t}}*\sum_{j1}^{s}e^{y_{j}^{t}}-(e^{y_{k}^{t}})^2}{(\sum_{j1}^{s}e^{y_{j}^{t}})^2} x_{k}^{t}-(x_{k}^{t})^2 \end{align} ∂ykt∂xkt(∑j1seyjt)2eykt∗∑j1seyjt−(eykt)2xkt−(xkt)2 将 ( 2 ) (2) (2)式和 ( 3 ) (3) (3)代入 ( 1 ) (1) (1)中得到 ∂ ( − l n p ) ∂ y k t − 1 p a l p h a ∗ b e t a x k t ( 1 − x k t ) a l p h a ∗ b e t a p − a l p h a ∗ b e t a p ∗ x k t \begin{align} \frac{\partial (-lnp)}{\partial y_{k}^{t}}-\frac{1}{p}\frac{alpha*beta}{x_{k}^{t}}(1-x_k^t)\\ \frac{alpha*beta}{p}-\frac{alpha*beta}{p*x_k^t}\notag \end{align} ∂ykt∂(−lnp)−p1xktalpha∗beta(1−xkt)palpha∗beta−p∗xktalpha∗beta 那么到这里我们整个梯度就全部推导完成了但是这个梯度是不对的因此接下来根据这个图来研究一下梯度的结构 我们在做动态规划的时候并不是每一个节点都被规划了。如果设定目标产生的字符串为 a b d d c e abddce abddce一共有 8 8 8拍也就是 a l p h a alpha alpha长成这样 然后我们在看看 y y y注意这里面的 y y y包含空格且与这个表 相对应 我们发现第一拍里面只有空格和字母 a a a是允许有值的也就是其余位置的 a l p h a alpha alpha和 b e t a beta beta都是 0 0 0这很容易理解在某一个拍某个字母完全没有可能取到的话在前向更新的概率 p p p中也不会被计算。因此来看一下梯度 a l p h a ∗ b e t a p − a l p h a ∗ b e t a p ∗ x k t \frac{alpha*beta}{p}-\frac{alpha*beta}{p*x_k^t} palpha∗beta−p∗xktalpha∗beta按照这个概率计算的话所有不可能取到的点的梯度都是 0 0 0但是这些字母对应的 y y y值是需要用梯度更新为 0 0 0的所以这就是昨天我训练了一大天都没啥用的原因当然还要包括推公式、初始化、没有归一化、梯度消失的错误。。。 所以最合理的办法就是分类讨论但是重新观察一下这个梯度公式 a l p h a ∗ b e t a p − a l p h a ∗ b e t a p ∗ x k t \frac{alpha*beta}{p}-\frac{alpha*beta}{p*x_k^t} palpha∗beta−p∗xktalpha∗beta发现 a l p h a ∗ b e t a p \frac{alpha*beta}{p} palpha∗beta在被更新到的节点位置这个值的取值应该是 x k t x_k^t xkt如果将梯度写成 x k t − a l p h a ∗ b e t a p ∗ x k t x_k^t-\frac{alpha*beta}{p*x_k^t} xkt−p∗xktalpha∗beta的话那么在没有更新到的节点位置其 a l p h a alpha alpha和 b e t a beta beta应该是 0 0 0虽然这个是归一化之后的 y y y但是起码梯度位置有值了因此实际的计算梯度为 ∂ ( − l n p ) ∂ y k t x k t − a l p h a ∗ b e t a p ∗ x k t \frac{\partial (-lnp)}{\partial y_{k}^{t}}x_k^t-\frac{alpha*beta}{p*x_k^t} ∂ykt∂(−lnp)xkt−p∗xktalpha∗beta 最终训练结果
[e, d, 0, d, d, e, d, d, 0]
[e, d, 0, d, d, e, d, d, 0]
[e, d, 0, d, d, e, d, d, 0]
[e, a, 0, d, d, e, d, c, 0]
[e, a, 0, d, d, e, d, c, 0]
[e, a, 0, d, d, d, d, c, 0]
[e, a, 0, d, d, d, d, c, e]
[e, a, 0, d, d, d, d, c, e]
[e, a, 0, d, d, d, d, c, e]
[e, a, 0, d, d, d, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[e, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]
[0, a, b, d, d, 0, d, c, e]整个过程代码
import numpy as np
import mathdef insert_blank(labels):l_ []l_.append(0)for i in range(len(labels)):l_.append(labels[i])l_.append(0)return l_def std_matrix(alpha):alpha math.e ** alphab alpha.sum(axis0)return alpha / bdef check():print(math.e ** alpha[-1][-1] math.e ** alpha[-2][-1] - math.e ** beta[0][1] - math.e ** beta[1][1])for i in range(alpha.shape[0]):for j in range(alpha.shape[1]):alpha[i, j] alpha[i, j] beta[i, j]print(alpha)def decode_fn(y, chars):res []for j in range(y.shape[1]):t -1max_ -1for i in range(y.shape[0]):if (y[i, j] max_):max_ y[i, j]t ires.append(chars[t])return res
the init processT 8
labels [a, b, d, d, c, e]
chars [0, a, b, c, d, e]
y np.random.rand(len(chars), T 1) # 这个还得包含空格,4个字符5拍
x std_matrix(y)
map_dict {0: 0, a: 1, b: 2, c: 3, d: 4, e: 4, f: 5}
alk 0.09
blank_label insert_blank(labels)
length len(labels)
length_ len(blank_label)
epoch 80train processfor m in range(epoch):alpha np.zeros((len(blank_label), T 1)) # 这个一共是5拍for i in range(alpha.shape[0]):for j in range(alpha.shape[1]):alpha[i, j] -math.infalpha[0][1] np.log(x[0][1]) # 这个是在第一个时刻选空格alpha[1][1] np.log(x[1][1]) # 这个是在第一个时刻选第一个字符beta np.ones((len(blank_label), T 1))for i in range(beta.shape[0]):for j in range(beta.shape[1]):beta[i, j] -math.infbeta[-1][-1] np.log(x[-1][-1])beta[-2][-1] np.log(x[-2][-1])forwardfor t in range(2, T 1):lim_down max(2 * (length - (T - t 1)) 1, 0)lim_up min(2 * t - 1, length_ - 1)for s in range(lim_down, lim_up 1, 1):alpha[s, t] math.e ** alpha[s, t - 1]if s - 1 0:alpha[s, t] math.e ** alpha[s - 1, t - 1]if s - 2 0 and blank_label[s] ! 0 and blank_label[s] ! blank_label[s - 2]:alpha[s, t] math.e ** alpha[s - 2, t - 1]alpha[s, t] np.log(alpha[s, t])alpha[s, t] np.log(x[map_dict[blank_label[s]], t])# print(alpha)backwardfor t in range(T - 1, 0, -1):lim_down max(2 * (length - (T - t 1)) 1, 0)lim_up min(2 * t - 1, length_ - 1)for s in range(lim_up, lim_down - 1, -1):beta[s, t] math.e ** beta[s, t 1]if s 1 length_:beta[s, t] math.e ** beta[s 1, t 1]if s 2 length_ and blank_label[s] ! 0 and blank_label[s] ! blank_label[s 2]:beta[s, t] math.e ** beta[s 2, t 1]beta[s, t] np.log(beta[s, t])beta[s, t] np.log(x[map_dict[blank_label[s]]][t])check np.zeros((len(chars), T 1))p math.e ** alpha[-1][-1] math.e ** alpha[-2][-1]# p math.e ** pgrad np.zeros((len(chars), T 1))for i in range(x.shape[0]):for j in range(x.shape[1]):ab 0for k in range(alpha.shape[0]):if alpha[k][j] -np.inf or beta[k][j] -np.inf:continueif blank_label[k] chars[i]:ab (math.e ** alpha[k][j]) * (math.e ** beta[k][j])check[i, j] ab / x[i, j]# if(x[i][j] 0):# print(x,y)# ab_x2 ab / (x[i, j] ** 2)grad[i, j] x[i, j] - ab/ (p*x[i,j])# print(y)y y - grad * alky np.where(y 0, y, 0)x std_matrix(y)print(decode_fn(x, chars))
若您对我的文章有任何疑问都欢迎指出 参考文章
文章1文章2
