viterbi算法_序列比对(十四)——viterbi算法和后验解码的比较

最新推荐文章于 2022-01-17 15:02:37 发布
最新推荐文章于 2022-01-17 15:02:37 发布
阅读量227 收藏
点赞数
文章标签： viterbi算法

8fe822a007db49dc3a88bd69b0ece76a.png

原创: hxj7

本文比较了viterbi算法求解最可能路径以及后验解码这两种不同的解码方法。

前文《序列比对（十）viterbi算法求解最可能路径》介绍了用viterbi算法求解最可能路径：在符号序列已知而状态序列未知时，最可能路径是：

20b16ea64a79547510c6fd225c87e106.png

本文将这两种方法比较了一下，看它们各自求解的路径差异是否显著。分两种情况：

一、如前面几篇文章一样，从公平骰子转为作弊骰子的概率是0.05。
效果如下：（其中Rolls一行是符号序列，也就是骰子投出的结果；Die一行是真实的骰子状态；Viterbi一行是viterbi算法求解出的最可能路径；PostDec一行是后验解码得出的路径）

f7225ff17b1abde92b3a1103bd1c05f2.png

二、将公平骰子转为作弊骰子的概率改为0.01。并将投骰子的次数增加到1000次。《生物序列分析》一书中说，此种情况下，viterbi求解的路径没有出现过'L'（即作弊骰子）。但是，笔者实验的结果是两种方法都可能出现'L'。效果如下：

f7225ff17b1abde92b3a1103bd1c05f2.png

具体代码如下：（以概率0.01，投骰子次数1000的情形为例写的代码）

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#define MIN_LOG_VALUE -99
//#define SAFE_EXP(x) ((x) < MIN_LOG_VALUE ? 0 : exp(x))

typedef char State;
typedef char Result;
State state[] = {'F', 'L'};   // 所有的可能状态
Result result[] = {'1', '2', '3', '4', '5', '6'};   // 所有的可能符号
double init[] = {0.9, 0.1};    // 初始状态的概率向量
double emission[][6] = {   // 发射矩阵：行对应着状态，列对应着符号
 1.0/6, 1.0/6, 1.0/6, 1.0/6, 1.0/6, 1.0/6,
 0.1, 0.1, 0.1, 0.1, 0.1, 0.5
};
double trans[][2] = {   // 转移矩阵：行和列都是状态
 0.99, 0.01,
 0.1, 0.9
};
const int nstate = 2;
const int nresult = 6;

double** fscore;  // 前向算法的得分矩阵
double** bscore;  // 后向算法的得分矩阵
double* scale;   // 缩放因子向量
double logScaleSum;

State* rst;   // 一串随机状态序列
Result* rres;  // 一串随机符号序列
State* vst;   // viterbi算法猜出来的状态序列
State* pst;   // 后验解码得到的状态序列

struct Unit {
 double v;
 int *p;
 int size;
};
typedef struct Unit* pUnit;

int random(double* prob, const int n);
void randSeq(State* st, Result* res, const int n);
int getResultIndex(Result r);
void printState(State* st, const int n);
void printResult(Result* res, const int n);
double forward(Result* res, const int n);
double backward(Result* res, const int n);
double** getPostProb(const int n);
void postDecode(double** prob, const int n);
void traceback(pUnit** a, const int l, const int i, State* st, const int m, int n);
void viterbi(Result* res, State* gst, const int n);

int main(void) {
 int i;
 int n = 1000;
 double** postProb;
 if ((rst = (State*) malloc(sizeof(State) * n)) == NULL || 
      (rres = (Result*) malloc(sizeof(Result) * n)) == NULL || 
      (scale = (double*) malloc(sizeof(double) * n)) == NULL || 
      (fscore = (double**) malloc(sizeof(double*) * nstate)) == NULL || 
      (bscore = (double**) malloc(sizeof(double*) * nstate)) == NULL || 
      (vst = (Result*) malloc(sizeof(Result) * n)) == NULL) {
 fputs("Error: out of space!n", stderr);
 exit(1);
  }
 for (i = 0; i < nstate; i++) {
 if ((fscore[i] = (double*) malloc(sizeof(double) * n)) == NULL || 
        (bscore[i] = (double*) malloc(sizeof(double) * n)) == NULL) {
 fputs("Error: out of space!n", stderr);
 exit(1);
    }
  }
  randSeq(rst, rres, n);
 //printState(rst, n);
 //printResult(rres, n);
  forward(rres, n);
  backward(rres, n);
  postProb = getPostProb(n);
  postDecode(postProb, n);
  viterbi(rres, vst, n);
 free(rst);
 free(rres);
 free(scale);
 free(fscore);
 free(bscore);
 free(vst);
 free(pst);
 for (i = 0; i < nstate; i++)
 free(postProb[i]);
 free(postProb);
}

// 根据一个概率向量从0到n-1随机抽取一个数
int random(double* prob, const int n) {
 int i;
 double p = rand() / 1.0 / (RAND_MAX + 1);
 for (i = 0; i < n - 1; i++) {
 if (p <= prob[i])
 break;
    p -= prob[i];
  }
 return i;
}

// 根据转移矩阵和发射矩阵生成一串随机状态和符号
void randSeq(State* st, Result* res, const int n) {
 int i, ls, lr;
  srand((unsigned int) time(NULL));
  ls = random(init, nstate);
  lr = random(emission[ls], nresult);
  st[0] = state[ls];
  res[0] = result[lr];
 for (i = 1; i < n; i++) {
    ls = random(trans[ls], nstate);
    lr = random(emission[ls], nresult);
    st[i] = state[ls];
    res[i] = result[lr];
  }
}

int getResultIndex(Result r) {
 return r - result[0];
}

// 前向算法计算P(x)
double forward(Result* res, const int n) {
 int i, l, k, idx;
 double logpx;
 // 缩放因子向量初始化
 for (i = 0; i < n; i++)
    scale[i] = 0;
 // 计算第0列分值
  idx = getResultIndex(res[0]);
 for (l = 0; l < nstate; l++) {
    fscore[l][0] = emission[l][idx] * init[l];
    scale[0] += fscore[l][0];
  }
 for (l = 0; l < nstate; l++)
    fscore[l][0] /= scale[0];
 // 计算从第1列开始的各列分值
 for (i = 1; i < n; i++) {
    idx = getResultIndex(res[i]);
 for (l = 0; l < nstate; l++) {
      fscore[l][i] = 0;
 for (k = 0; k < nstate; k++) {
        fscore[l][i] += fscore[k][i - 1] * trans[k][l];
      }
      fscore[l][i] *= emission[l][idx];
      scale[i] += fscore[l][i];
    }
 for (l = 0; l < nstate; l++)
      fscore[l][i] /= scale[i];
  }
 // P(x) = product(scale)
 // P(x)就是缩放因子向量所有元素的乘积
  logpx = 0;
 for (i = 0; i < n; i++)
    logpx += log(scale[i]);
 //printf("forward: logP(x) = %fn", logpx);
  logScaleSum = logpx;
/*
  for (l = 0; l < nstate; l++) {
    for (i = 0; i < n; i++)
      printf("%f ", fscore[l][i]);
    printf("n");
  }
*/
 return exp(logpx);
}

// 后向算法计算P(x)
// backward算法中使用的缩放因子和forward中的一样
double backward(Result* res, const int n) {
 int i, l, k, idx;
 double tx, logpx;
 // 计算最后一列分值
 for (l = 0; l < nstate; l++)
    bscore[l][n - 1] = 1 / scale[n - 1];
 // 计算从第n - 2列开始的各列分值
 for (i = n - 2; i >= 0; i--) {
    idx = getResultIndex(res[i + 1]);
 for (k = 0; k < nstate; k++) {
      bscore[k][i] = 0;
 for (l = 0; l < nstate; l++) {
        bscore[k][i] += bscore[l][i + 1] * trans[k][l] * emission[l][idx];
      }
    }
 for (l = 0; l < nstate; l++)
      bscore[l][i] /= scale[i];
  }
 // 计算P(x)
  tx = 0;
  idx = getResultIndex(res[0]);
 for (l = 0; l < nstate; l++)
    tx += init[l] * emission[l][idx] * bscore[l][0];
  logpx = log(tx) + logScaleSum;
 //printf("backward: logP(x) = %fn", logpx);
/*
  for (l = 0; l < nstate; l++) {
    for (i = 0; i < n; i++)
      printf("%f ", bscore[l][i]);
    printf("n");
  }
*/
 return exp(logpx);  
}

// 计算后验概率
double** getPostProb(const int n) {
 int i, k;
 double** postProb;
 //double logdiff;
 if ((postProb = (double**) malloc(sizeof(double*) * nstate)) == NULL) {
 fputs("Error: out of space!n", stderr);
 exit(1);  
  }
 for (k = 0; k < nstate; k++) {
 if ((postProb[k] = (double*) malloc(sizeof(double) * n)) == NULL) {
 fputs("Error: out of space!n", stderr);
 exit(1);
    }
  }
 // 计算后验概率
 for (i = 0; i < n; i++) {
 for (k = 0; k < nstate; k++) {
      postProb[k][i] = scale[i] * fscore[k][i] * bscore[k][i];
    }
  }
/*
  printf("n");
  printf("Posterior Probabilities:n");
  for (k = 0; k < nstate; k++) {
    for (i = 0; i < n; i++)
      printf("%f ", postProb[k][i]);
    printf("n");
  }
*/
 return postProb;
}

void postDecode(double** prob, const int n) {
 int i, k;
 double maxCol;
 int idx;
  State* st;
 if ((st = (State*) malloc(sizeof(State) * n)) == NULL) {
 fputs("Error: out of space!n", stderr);
 exit(1);    
  }
 for (i = 0; i < n; i++) {
    idx = 0;
    maxCol = prob[0][i];
 for (k = 1; k < nstate; k++)
 if (prob[k][i] > maxCol) {
        maxCol = prob[k][i];
        idx = k;
      }
    st[i] = state[idx];
  }
/*
  printf("n");
  printf("Posterior Decode:n");
  printState(st, n);
*/
  pst = st;
}

void printState(State* st, const int n) {
 int i;
 for (i = 0; i < n; i++)
 printf("%c", st[i]);
 printf("n");
}

void printResult(Result* res, const int n) {
 int i;
 for (i = 0; i < n; i++)
 printf("%c", res[i]);
 printf("n");  
}

void traceback(pUnit** a, const int l, const int i, State* st, const int m, int n) {
 int j, k;
 int ll = 125;   // 每行打印几个元素
 int nl, nd;
  pUnit pu = a[l][i];
 if (! i) {
    st[n] = state[l];
    nl = m / ll;
    nd = m % ll;
 for (k = 0; k < nl; k++) {
 printf("Rollst");
      printResult(rres + k * ll, ll);
 printf("Diet");
      printState(rst + k * ll, ll);
 printf("Viterbit");
      printState(st + k * ll, ll);
 printf("PostDect");
      printState(pst + k * ll, ll);
 printf("n");
    }
 if (nd > 0) {
 printf("Rollst");
      printResult(rres + k * ll, nd);
 printf("Diet");
      printState(rst + k * ll, nd);
 printf("Viterbit");
      printState(st + k * ll, nd);
 printf("PostDect");
      printState(pst + k * ll, nd);
 printf("n"); 
    }
 printf("nn");
 return;  
  }
  st[n] = state[l];
 for (j = 0, k = 0; j < nstate && k < pu->size; j++) {
 if (pu->p[j]) {
      traceback(a, j, i - 1, st, m, n - 1);
      k++;
    }
  }
}

void viterbi(Result* res, State* gst, const int n) {
 double maxCol;
 double* tm;
 int i, j, k, l;
 int idx;
  pUnit** aUnit;  // 得分矩阵
 double* loginit;   // 每个元素都取log后的初始向量
 double** logem;  // 每个元素都取log后的发射矩阵
 double** logtrans;  // 每个元素都取log后的转移矩阵
 double v0 = 0;   // v0(0)的log值
 // 初始化
 if ((aUnit = (pUnit**) malloc(sizeof(pUnit*) * nstate)) == NULL || 
      (loginit = (double*) malloc(sizeof(double) * nstate)) == NULL || 
      (logem = (double**) malloc(sizeof(double*) * nstate)) == NULL || 
      (logtrans = (double**) malloc(sizeof(double*) * nstate)) == NULL) {
 fputs("Error: out of space!n", stderr);
 exit(1);
  }
 for (i = 0; i < nstate; i++) {
 if ((aUnit[i] = (pUnit*) malloc(sizeof(pUnit) * n)) == NULL || 
        (logem[i] = (double*) malloc(sizeof(double) * nresult)) == NULL || 
        (logtrans[i] = (double*) malloc(sizeof(double) * nstate)) == NULL) {
 fputs("Error: out of space!n", stderr);
 exit(1);
    }
 for (j = 0; j < n; j++) {
 if ((aUnit[i][j] = (pUnit) malloc(sizeof(struct Unit))) == NULL || 
          (aUnit[i][j]->p = (int*) malloc(sizeof(int) * nstate)) == NULL) {
 fputs("Error: out of space!n", stderr);
 exit(1);
      }
 for (k = 0; k < nstate; k++)
        aUnit[i][j]->p[k] = 0;
      aUnit[i][j]->size = 0;
    }
  }
 if ((tm = (double*) malloc(sizeof(double) * nstate)) == NULL) {
 fputs("Error: out of space!n", stderr);
 exit(1);    
  }
 // 初始向量取log值
 for (i = 0; i < nstate; i++)
    loginit[i] = init[i] == 0 ? MIN_LOG_VALUE : log(init[i]);
 // 发射矩阵取log值
 for (i = 0; i < nstate; i++)
 for (j = 0; j < nresult; j++)
      logem[i][j] = emission[i][j] == 0 ? MIN_LOG_VALUE : log(emission[i][j]);
 // 转移矩阵取log值
 for (i = 0; i < nstate; i++)
 for (j = 0; j < nstate; j++)
      logtrans[i][j] = trans[i][j] == 0 ? MIN_LOG_VALUE : log(trans[i][j]); 
 // 动态规划计算得分矩阵
 // 首先计算第0列，因为第0列的值和vk(0)有关
 // v0(0) = 1, vk(0) = 0 for k>0
  idx = getResultIndex(res[0]);
 for (l = 0; l < nstate; l++)
    aUnit[l][0]->v = v0 + loginit[l] + logem[l][idx];
 // 计算从第1列开始的各列
 for (i = 1; i < n; i++) {
    idx = getResultIndex(res[i]);
 for (l = 0; l < nstate; l++) {
      maxCol = tm[0] = aUnit[0][i - 1]->v + logtrans[0][l];
 for (k = 1; k < nstate; k++) {
        tm[k] = aUnit[k][i - 1]->v + logtrans[k][l];
 if (tm[k] > maxCol)
          maxCol = tm[k];
      }
      aUnit[l][i]->v = maxCol + logem[l][idx];
 for (k = 0; k < nstate; k++)
 if (tm[k] == maxCol) {
          aUnit[l][i]->p[k] = 1;
          aUnit[l][i]->size++;
        }
    }
  }
/*
  // 打印得分矩阵
  for (l = 0; l < nstate; l++) {
    for (i = 0; i < n; i++)
      printf("%f ", aUnit[l][i]->v);
    printf("n");
  }
*/
  maxCol = aUnit[0][n - 1]->v;
 for (l = 1; l < nstate; l++)
 if (aUnit[l][n - 1]->v > maxCol)
      maxCol = aUnit[l][n - 1]->v;
 for (l = 0; l < nstate; l++)
 if (aUnit[l][n - 1]->v == maxCol) {
      traceback(aUnit, l, n - 1, gst, n, n - 1);
    }
}

（公众号：生信了）

weixin_39926639
关注
语音识别维特比解码_人工智能、通信领域的解码算法对比：维特比和BeamSearch...
weixin_39537298的博客
01-04 360
人工智能自然语言处理领域中，很多都能转换为序列的预测问题，比如分词算法可以转化为预测每个字的标签B(词开始位置)、M(词中间位置)、E(词结束位置)、S(单字作为词)语音识别、机器翻译、文本生成算法可以认为是预测每个位置的词语输入法里面的拼音转汉字等等而数字通信领域，接收机侧做的工作，本质上也是二进制0、1序列的解码，可以看成是二进制序列的预测问题。同为序列预测问题，为什么分词用维特比算法，机器翻...
维特比（Viterbi）算法解最优状态序列
weixin_30268921的博客
06-14 828
最优状态序列：一般是指在给定的HMM模型中，对于观测到的序列O，能产生该观测序列的概率最大的状态序列。 维特比算法运用 动态规划 求解这种最优状态序列。 定义：维特比变量：δt（i）是指 t 时刻时观测序列为O1O2···Ot，且qt = Si的所有路径中的概率最大值。（前t-1个时刻的状态q1q2···qt-1qt可能是任何一种组合） δt（i） = max P（O1O2···Ot，q...
序列比对（14）viterbi算法和后验解码的比较
生信了
08-19 472
本文比较了viterbi算法求解最可能路径以及后验解码这两种不同的解码方法。 前文《序列比对（十）viterbi算法求解最可能路径》介绍了用viterbi算法求解最可能路径：在符号序列已知而状态序列未知时，最可能路径是： 本文将这两种方法比较了以下，看它们各自求解的路径差异是否显著。分两种情况： 一、如前面几篇文章一样，从公平骰子转为作弊骰子的概率是0.05。 效果如下：（其中Rolls一行...
语音识别维特比解码_HMM连续语音识别中Viterbi算法的优化及应用
weixin_34457571的博客
01-13 293
HMM连续语音识别中Viterbi算法的优化及应用袁俊【期刊名称】《电子技术》【年(卷),期】2001(028)002【摘要】基于HMM连续语音识别系统声学层的最佳路径识别算法有很多种,其中Viterbi算法在CPU时间、存储量及实施方面性能都较为优越,是在实际应用中经常采用的方法之一.但它还不直接适用于实时系统,其算法压力仍是影响整个系统效率的瓶颈问题.文章就此提出了该算法的两种改进,Viter...
最大似然序列检测中的Viterbi算法的实现* (2005年)
06-14
讨论Viterbi算法在最大似然序列检测中的实现。先给出带宽受限，存在失真且先验未知以及具有AWGN条件下信道的一种数学模型。由此得到Viterbi算法在最大似然序列检测中的表示形式，且根据其在此信道模型下的算法描述，具体分析了三种信道下最大似然序列检测中Viterbi算法的设计问题。使用MATLAB仿真实现并根据仿真结果分析其性能。提出Viterbi译码算法对于信道特性无论好坏是普遍适用的，大大补偿了存在符号间干扰（ISI）的信道的接收性能，降低了误码率。是一种信道存在符号间干扰（ISI）的接收性能的最
viterbi算法1
08-08
由于其高效性和准确性，Viterbi算法也被应用于语音识别、模式识别、生物信息学（如序列比对）以及无线通信等多个领域。 总结来说，Viterbi算法是解决离散时间马尔可夫过程状态估计问题的一种有效工具，它通过动态...
viterbi算法.pdf
06-10
Viterbi算法的原理和用于序列比对的动态规划算法如Needleman-Wunsch算法有相似之处。具体来说，对于观测序列中的每个观测值i和每个状态k，在位置x结束时最可能路径的概率pl(i,x)可以通过以下公式计算： pl(i,x) = ...
viterbi algorithm 维特比算法
07-28
例如，在生物信息学中，该算法可以用来进行基因序列的比对；在人工智能领域，它可以用于改进机器学习模型的训练过程。 #### 七、总结 维特比算法是一种高效且强大的工具，用于解决离散时间有限状态马尔可夫过程的...
通用的维特比算法实现
01-02
4. **生物信息学**：在基因序列分析中，寻找蛋白质折叠路径或序列比对。 ### 实现细节 `Viterbi__hankcs`可能是一个具体的维特比算法实现，通常包括以下组件： - **状态转移矩阵**：存储了从一个状态转移到另一个...
Viterbi algorithm
10-23
维特比算法（Viterbi Algorithm）是一种在序列模型中寻找最可能事件序列的方法，尤其在通信、语音识别、自然语言处理等领域有广泛应用。该算法基于动态规划思想，通过优化状态转移路径，来找到最有可能发生的序列...
硬判决Viterbi译码matlab代码
06-10
硬判决Viterbi译码代码
Viterbi-decoder:卷积码仿真，使用维特比算法的解码器
05-02
#卷积码仿真 代码内包含基本的卷积码码编码器，译码器（维特比）实现方式，以及BPSK通信系统的基本仿真原理（AWGN信道）。 ##1. 运行环境和使用方法 运行环境：MATLAB 2014a 使用方法：设置相应参数，运行CC_Simulation。 ##2. 代码说明 代码供学习使用，这比MATLAB工具箱中的函数要慢上很多。 vitbiDecoder的译码结果和vitdec的不一样，一般来说是更好的。这是因为译码过程中在一组码完全译码之后，才进行了比较判决，同时最后选择了最大的metric路径。 注意vitbiDecoder还有一些潜在的问题没有解决。 ##3.维特比算法示例
实体识别中，或序列标注任务中的维特比Viterbi解码
高颜值的杀生丸(此博客转载自我的博客园)
04-26 391
看懂这个算法，首先要了解序列标注任务 QQ522414928 可以在线交流 大体做一个解释，首先需要4个矩阵，当然这些矩阵是取完np.log后的结果， 分别是：初始strat→第一个字符状态的概率矩阵，转移概率矩阵，发射概率矩阵，最后一个字符状态→end结束的概率矩阵， 这些概率矩阵可以是通过统计得到，或者是LSTM+crf这种训练迭代得到。 zero_log 指的是在统...
序列比对(十)——viterbi算法求解最可能路径
生信了
07-08 1437
原创: hxj7 本文介绍了如何使用viterbi算法得到概率最大的路径。 前文《序列比对（九）从掷骰子说起HMM》已经通过投骰子的例子介绍了HMM的基本概念，引用如下： 那么如何通过已知的符号序列来预测未知的状态序列呢？首先想到的自然是最大似然法，即看不同的状态序列下的概率，选取使整体概率最大的那个状态序列。如果将一串状态序列称为一条路径的话，我们感兴趣的就是找到一条最大似然的路径。 如《...
语音识别—Viterbi解码
Xwei1226的博客
05-10 2184
Viterbi解码理论与实战 笔者最近着手研究基于HMM的语音识别系统，之前博文基于C++工具手写了提取MFCC语音特征（具体可以观看之前博文），最同时，也对基于GMM-HMM的语音识别训练过程进行了理论推导，现本文对基于Viterbi的解码方法进行详细的研究。 曾看过很多语音识别书（余栋的语音识别实战、陈果 果的kaldi实战以及张雪英的数位...
viterbi算法_序列比对(十)——viterbi算法求解最大似然路径
weixin_39953618的博客
12-11 692
原创：hxj7本文介绍了如何使用viterbi算法得到概率最大的路径。前文《序列比对（九）从掷骰子说起HMM》已经通过投骰子的例子介绍了HMM的基本概念，引用如下：那么如何通过已知的符号序列来预测未知的状态序列呢？首先想到的自然是最大似然法，即看不同的状态序列下的概率，选取使整体概率最大的那个状态序列。如果将一串状态序列称为一条路径的话，我们感兴趣的就是找到一条最大似然的路径。如《序列比对（八）第...
viterbi java_viterbi 维特比解码过程，状态转移矩阵
weixin_34064233的博客
02-28 405
viterbi过程1.hmm类似。 状态转移，发射概率2.逐次计算每个序列节点的所有状态下的概率值，最大概率值对应的index。3.概率值的计算，上一个节点的概率值*转移概率+当前概率值。4.最后取出最大的一个值对应的indexes难点： 理解viterbi的核心点，在于每个时间步都保留每一个可视状态，每一个可视状态保留上一个时间步的最大隐状态转移，每一个时间步t记录上一个最大概率转移过来的...
维特比译码算法（Viterbi decoding algorithm）
weixin_45354197的博客
01-17 2323
参考链接 卷积码译码之维特比译码算法（Viterbi decoding algorithm） （一）基本概念 1.经典通信系统 衡量译码器性能：译码后的错误概率 维特比译码是基于距离译码 （二）算法介绍 背景知识：卷积码的编码过程与网格图中的一条路径对应，即输入序列的编码过程与网格图中的路径一一对应。当序列长度为xxx时，网格中有 2x2^x2x条不同的路径和编码器的2x2^x2x种输入序列对应。在网格图中，每个状态转移的过程中都会输出编码码字。由于译码过程也建立在网格图中，并且从全零状态
CRF损失函数与维特比解码
m0_45283671的博客
03-25 2274
本节是在上一篇博客的基础上写的。 在上一篇博客我们学会了如何通过BILSTM提取特征得到发射分数，如何荣国CRF层约束标签得到转移分数。 对于一个标签序列，我们可以通过发射分数和转移分数的和计算这条路径的最终得分。这是前向学习的内容，我们知道深度学习需要定义损失函数来进行反向传播，更新梯度。对于序列标注的模型，如何定义损失函数呢？ 我们可以使用CRF损失函数学习模型参数。在这里维特比解码要解决的问题是对于一个新的样本过来我们如何通过发射分数和转移分数在所有的可能路径中找到最优路径。 前向算法 概率计算问题(
viterbi算法_彻底了解 BiLSTM 和 CRF 算法
最新发布
06-12
BiLSTM和CRF是两种常用的序列标注算法。其中，BiLSTM是一种基于深度学习的模型，CRF则是一种基于概率图模型的算法。 BiLSTM是一种循环神经网络，它可以对输入的序列进行逐个元素的处理，并通过学习隐藏状态来捕捉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值