首先我们需要明确$ctcloss$是用来做什么的。比如说我们要生成的目标字符串长度为$l$，而这个字符串包含$s$个字符，字符串允许的最大长度为$L$，这里我们认为一个位置是一个时间步，就是一拍，记为$T$。
对于这个允许最大长度，需要做出一些解释，我们需要定义一个生成字符串的规则，因为训练的时候，这个标签的长度是不一样的，所以我们需要引入空格来生成字符串，那么相应的，关于空格定义以下两条规则：

1. 空格与空格之间的字符串是可以去掉重复字母的
2. 使用空格间隔的两个部分串不能去重，比如说这个串长成：cc cc，在运用上述两条规则之后应该变成c c

举例来说，对于目标生成串如果是$CAT$的话，那么在时间拍为$5$拍的情况下，他有这以下$28$条路径可以生成$CAT$

注：上述图片引自这里，博主对这篇文章加以致谢，还好有这个文章让我对$ctcloss$有了初步的认识。

因此我们首先拿在手里的是一个随机矩阵为$y$，这个矩阵的形状是$[k,T]$，其中$y[i,j]$表示的是在第$j$个时间步，该字符为$i$的概率，而我们需要做的是训练这个$y$矩阵，让他最终产生指定字符串的概率$p$最大，所以我们设置$-ln(p)$为损失函数，目标就是让这个损失函数最小。
那么我们应该怎么做呢？你可以枚举出这全部$28$条路径的概率，$likethis$，然后把他们相加之后求损失和。

但是我知道你一定不想这么做。所以呢，我们需要使用一种更加简洁的方法来求这个概率，咋做呢？这里就要放上这张过程图了。

首先对字符串进行了插入空格的操作，我一开始的时候不给他插入空格不行，必须得考虑每一步能不能取到空格，并且状态转移的时候，还要考虑从第几个空格转移过来，非常麻烦，不如直接插入空格。接下来使用动态规划的方法来代替暴力搜索，分析$t$时刻由$t-1$时刻字符的状态转移方程：

1. 在$t$时刻，能取到$s$字符，那么这个字符可以由$t-1$时刻的$s$字符转移过来，两个一样的字符消去就行了呗。
2. 由$s-1$字符转移过来$，$就是$\_C\_A\_T\_$的$T$接在$\_$后面的情况。
3. 从第$s-2$个字符转移过来，这个时候第$s$个字符和第$s-2$个字符必须不能相同，否则的话就是$\_C\_A\_A\_T\_$的两个$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]

但是你一定会问弄这个动态规划矩阵有个锤子用，我们来看看：
对于$alpha$矩阵当中的任意一个元素来说，我们可以得到以下的表达式，其中$l$是任意一个可能产生字符串的路径，$\pi$是全部路径，$l_t$代表这个路径上在第$t$拍上的字符，$P$为概率。
$$alpha[i,t]=P(l_t)\sum _{l\in \pi }\prod _{t^{\prime }=1}^{t-1}P(l_{t^{\prime }})$$
那么如果求出后向传播的矩阵$beta$：
$$beta[i,t]=P(l_t)\sum _{l\in \pi }\prod _{t^{\prime }=t+1}^{T}P(l_{t^{\prime }})$$
就能得到矩阵：
$$alpha[i,t]\ast beta[i,t]=P(l_t)\sum _{l\in \pi }\prod _{t^{\prime }=1}^{T}P(l_{t^{\prime }})$$
所以我们非常想求的总概率$p={\sum }_{l\in \pi }{\prod }_{t^{\prime }=1}^{T}P(l_{t^{\prime }})$就可以使用$\frac{alpha[i,t]\ast beta[i,t]}{P(l_t)}$来表示。
公式推导鸣谢：这里
注：这只是我大概的理解，不能十分完备的使用原文章中的符号
接下来就到了非常鸡冻人心的训练过程，差点没给我训练死了。因为改了一天这个梯度公式，并且我体会了什么是梯度消失，$softmax$的作用，接下来将详细记录我训练的这个过程，应该只是我记得的了，其中非常感谢这几篇文章的帮助，尤其是在晚上八点还是没有结果的时候看到的这篇文章，但是当时通过死亡调试梯度矩阵已经反应过来是梯度问题了hh。首先先声明一下：我不能完全保证我的梯度求解没有问题，但是的确训练出了结果，并且参考多篇博客，梯度的结果全都不一样，因此我只能找到一个我认为最合理的梯度来进行梯度下降。
那么我们再来捋一下思路：首先要最小化$-ln(p)$，而前面已经求出$p=\frac{alpha[i,t]\ast beta[i,t]}{P(l_t)}$，这里将$P(l_t)$换成$y_k^t$来表示，就是在$t$时刻的第$k$个字符的概率。我们想对$y$求偏导，但有一个$bug$就是$y$他不一定每一列的和都是$1$，所以需要对他进行$softmax$操作，因此，我们用$x_k^t$代表经过$softmax$之后的$y_k^t$。分析一下$y$经过所有变换得到$p$的过程：$y\sim softmax\sim alpha+beta\sim p$。需要求的梯度经过以上分析可以表示成为：
$$\begin{array}{r}\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{array}$$
前面已经知道：$p=\frac{alpha[i,t]\ast beta[i,t]}{x_k^t}$，在这个公式当中$alpha、beta$与$x_k^t$并不是完全没有关系的，他们可以表示成$cons1\ast x_k^t$的形式，其中$cons1$是到达$x_k^t$字符之前的所有可能字符概率乘积的和，$cons2$同理，值得注意的是，我们的假定是字符的概率是可以相乘的，也就是完全独立的，因此$cons1$和$cons2$对于$x_k^t$来说是常数。所以$p$应该化简为$cons1\ast cons2\ast x_k^t$，其中 $cons1=\frac{alpha}{x_k^t},cons2=\frac{beta}{x_k^t}$，所以
$$\begin{array}{r}\frac{\partial p}{\partial x_k^t}=\frac{alpha}{x_k^t}\frac{beta}{x_k^t}\end{array}$$
由于$x_k^t=softmax(y_k^t)$，即$x_k^t=\frac{e^{y_k^t}}{{\sum }_{j=1}^s{e}^{y_j^t}}$，所以有
$$\begin{array}{r}\frac{\partial x_k^t}{\partial y_k^t}=\frac{e^{y_k^t}\ast {\sum }_{j=1}^s{e}^{y_j^t}-(e^{y_k^t}{)}^2}{({\sum }_{j=1}^s{e}^{y_j^t}{)}^2}=x_k^t-(x_k^t{)}^2\end{array}$$
将$(2)$式和$(3)$代入$(1)$中得到：
$$\begin{array}{rl}\frac{\partial (-lnp)}{\partial y_k^t}& =-\frac{1}{p}\frac{alpha\ast beta}{x_k^t}(1-x_k^t)\\ & =\frac{alpha\ast beta}{p}-\frac{alpha\ast beta}{p\ast x_k^t}\end{array}$$
那么到这里我们整个梯度就全部推导完成了，接下来我们根据这个图来研究一下梯度的结构：

我们在做动态规划的时候，并不是每一个节点都被规划了。我们设定目标产生的字符串为$abddce$，一共有$8$拍，也就是$alpha$长成这样：

然后我们在看看$y$，注意这里面的$y$包含空格，且与这个表
相对应：

我们发现第一拍里面只有空格和字母$a$是允许有值的，也就是其余位置的$alpha$和$beta$都是$0$，这很容易理解，在某一个拍某个字母完全没有可能取到的话，在前向更新的概率$p$中也不会被计算。因此我们来看一下梯度$\frac{alpha\ast beta}{p}-\frac{alpha\ast beta}{p\ast x_k^t}$，按照这个概率计算的话，所有不可能取到的点的梯度都是$0$，但是这些字母对应的$y$值是需要用梯度更新为$0$的，所以这就是昨天我训练了一大天都没啥用的原因，当然还要包括推公式、初始化、没有归一化、梯度消失的错误。。。
所以最合理的办法就是分类讨论，但是我们重新观察一下这个梯度公式$\frac{alpha\ast beta}{p}-\frac{alpha\ast beta}{p\ast x_k^t}$，发现$\frac{alpha\ast beta}{p}$，在被更新到的节点位置，这个值的取值应该是$x_k^t$，如果将梯度写成$x_k^t-\frac{alpha\ast beta}{p\ast x_k^t}$的话，那么在没有更新到的节点位置，其$alpha$和$beta$应该是$0$，虽然这个是归一化之后的$y$，但是起码梯度位置有值了，因此我们实际的计算梯度为：
$$\frac{\partial (-lnp)}{\partial y_k^t}=x_k^t-\frac{alpha\ast beta}{p\ast x_k^t}$$
最终训练结果：

['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(axis=0)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 process
'''
T = 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 = 80
'''
train process
'''
for 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])'''forward'''for 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)'''backward'''for 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. 文章1
2. 文章2