使用ctcloss训练矩阵生成目标字符串

九思Atopos2023-08-26 13:29

首先我们需要明确 c t c l o s s ctcloss ctcloss是用来做什么的。比如说我们要生成的目标字符串长度为 l l l，而这个字符串包含 s s s个字符，字符串允许的最大长度为 L L L，这里我们认为一个位置是一个时间步，就是一拍，记为 T T T。

对于这个允许最大长度，需要做出一些解释，我们需要定义一个生成字符串的规则，因为训练的时候，这个标签的长度是不一样的，所以我们需要引入空格来生成字符串，那么相应的，关于空格定义以下两条规则：

  1. 空格与空格之间的字符串是可以去掉重复字母的
  2. 使用空格间隔的两个部分串不能去重，比如说这个串长成：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时刻字符的状态转移方程：

  1. 在 t t t时刻，能取到 s s s字符，那么这个字符可以由 t − 1 t-1 t−1时刻的 s s s字符转移过来，两个一样的字符消去就行了呗。
  2. 由 s − 1 s-1 s−1字符转移过来 ， ， ，就是 _ C _ A _ T _ \_C\_A\T\ C_A_T_的 T T T接在 _ \ _后面的情况。
  3. 从第 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越过中间的空格连在一起，这不铁定消去了。

所以状态转移使用如下的方法实现：

python 复制代码 
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_{t'=1}^{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_{t'=t+1}^{T} P(l_{t'}) beta[i,t]=P(lt)l∈π∑t′=t+1∏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_{t'=1}^{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_{t'=1}^{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)} p=P(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 alpha+beta \sim p y∼softmax∼alpha+beta∼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}} p=xktalpha[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}} cons1=xktalpha,cons2=xktbeta，所以
∂ 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∂p=xktalphaxktbeta

由于 x k t = s o f t m a x ( y k t ) x_{k}^{t}=softmax(y_{k}^{t}) xkt=softmax(ykt)，即 x k t = e y k t ∑ j = 1 s e y j t x_{k}^{t}=\frac{e^{y_{k}^{t}}}{\sum_{j=1}^{s}e^{y_{j}^{t}}} xkt=∑j=1seyjteykt，所以有
∂ 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_{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{align} ∂ykt∂xkt=(∑j=1seyjt)2eykt∗∑j=1seyjt−(eykt)2=xkt−(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

最终训练结果：

python 复制代码 
['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']

整个过程代码：

python 复制代码 
import numpy as np
import math


def 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 ** alpha
    b = alpha.sum(axis=0)
    return alpha / b

def 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 = -1
        max_ = -1
        for i in range(y.shape[0]):
            if (y[i, j] > max_):
                max_ = y[i, j]
                t = i
        res.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.inf
    alpha[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.inf
    beta[-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 ** p
    grad = np.zeros((len(chars), T + 1))
    for i in range(x.shape[0]):
        for j in range(x.shape[1]):
            ab = 0
            for k in range(alpha.shape[0]):
                if alpha[k][j] == -np.inf or beta[k][j] == -np.inf:
                    continue
                if 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 * alk
    y = np.where(y > 0, y, 0)
    x = std_matrix(y)
    print(decode_fn(x, chars))

若您对我的文章有任何疑问都欢迎指出

参考文章：

  1. 文章1
  2. 文章2
相关推荐
Deepcong2 天前
多个摄像机画面融合：找到同一个目标在多个画面中的伪三维坐标，找出这几个摄像头间的转换矩阵
人工智能·线性代数·矩阵
雷达学弱狗2 天前
右旋圆极化散射后的stocks矢量 与T3矩阵的关系
线性代数·矩阵
不穿铠甲的穿山甲2 天前
glsl中vec4是行矩阵还是列矩阵
线性代数·矩阵
HP-Patience2 天前
【Word2Vec】传统词嵌入矩阵训练方法
人工智能·矩阵·word2vec
哈市雪花2 天前
图形几何之美系列：仿射变换矩阵之先转后偏
线性代数·矩阵·空间变换·先转后偏·矩阵推导
哈市雪花2 天前
图形几何之美系列：仿射变换矩阵之Y-Up和Z-Up
线性代数·矩阵·转换·空间变换·y up·z up
平头哥在等你2 天前
求一个3＊3矩阵对角线元素之和
c语言·线性代数·算法·矩阵
彭彭不吃虫子3 天前
将一个二维矩阵，螺旋遍历展开为一维列表
线性代数·算法·矩阵
yangmc043 天前
二维前缀和 子矩阵的和
c语言·数据结构·c++·git·算法·矩阵·图论
耗不尽的先生3 天前
【数学】通用三阶矩阵特征向量的快速求法 超简单！！！
人工智能·线性代数·矩阵·特征向量
热门推荐
01软件工程从理论到实践客观题汇总(头歌第一章至第八章)02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04VSCode插件 —— Cody AI （免费AI助手！）05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06Windows10安装PCL1.14.0及点云配准07【QuikGraph】C#调用第三方库实现迪杰斯特拉(Dijkstra)算法功能08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10文件或文件夹名称中有空格如何批量去除