Recurrent neural network language modeling toolkit 源码走读(六)

时间：2015-04-01 11:27:34 阅读：534 评论：0 收藏：0 [点我收藏+]

系列前言

参考文献：

RNNLM - Recurrent Neural Network Language Modeling Toolkit(点此阅读)
Recurrent neural network based language model(点此阅读)
EXTENSIONS OF RECURRENT NEURAL NETWORK LANGUAGE MODEL(点此阅读)
Strategies for Training Large Scale Neural Network Language Models(点此阅读)
STATISTICAL LANGUAGE MODELS BASED ON NEURAL NETWORKS(点此阅读)
A guide to recurrent neural networks and backpropagation(点此阅读)
A Neural Probabilistic Language Model(点此阅读)
Learning Long-Term Dependencies with Gradient Descent is Difficult(点此阅读)
Can Artificial Neural Networks Learn Language Models?(点此阅读)

这篇主要介绍一个网络前向计算的函数，内容量也挺大的。在此之前，解释一下rnn的输出层分解，和从神经网络的角度去看最大熵模型。先看一下原论文中最"标准"的rnn结构，这个结构是最原始的，后面会有系列的扩展，详见参考文献的第3篇。

上图是最原始的循环神经网络的结构，关于它的前向计算和学习算法我在rnnlm原理以及bptt数学推导这篇文章有详细的写过。简要在写一下。上面这个网络的输出层有|V|维，在整个前向计算完毕后，我们得到的结果就是预测词的概率分布，即yt = P(wt+1 | wt,st-1), wt+1是要预测的词.

这是我从前篇文章截图来的，由于网络输出层部分计算量很大，特别是当|V|很大时，计算量会更大。于是Mikolov提出了将输出层分解，并不是在所有单词上计算概率的分布，而是在某一类单词中计算概率分布，这样就会大大降低计算量。于是有了如下图：

现在的计算预测词的概率分布变成了如下：

其中，yV‘(t)表示在V中的部分词语，至于这个部分是哪一部分，得看怎么把这些单词分类了，ci表示类别, wt+1表示期望词。这样在前向计算概率分布时，就先计算在期望词的类别的概率分布，然后在当前预测词所在类别的词语上计算概率分布，这个待会会在源代码中看到。

void CRnnLM::computeNet(int last_word, int word)
{
	//last_word表示当前输入层所在的词
	//word表示要预测的词
    int a, b, c;
    real val;
    double sum;   //sum is used for normalization: it's better to have larger precision as many numbers are summed together here
    
	//将last_word对应的神经元ac值为1,也可以看做是对该词的1-of-V的编码
    if (last_word!=-1) neu0[last_word].ac=1;
	
    //下面计算输入到隐层的部分
    for (a=0; a<layer1_size; a++) neu1[a].ac=0;
    for (a=0; a<layerc_size; a++) neuc[a].ac=0;
    
	//这里计算的是s(t-1)与syn0的乘积
    matrixXvector(neu1, neu0, syn0, layer0_size, 0, layer1_size, layer0_size-layer1_size, layer0_size, 0);
	
	//这里计算将last_word编码后的向量(大小是vocab_size,分量只有一个为1,其余为0)与syn0的乘积
    for (b=0; b<layer1_size; b++) {
        a=last_word;
        if (a!=-1) neu1[b].ac += neu0[a].ac * syn0[a+b*layer0_size].weight;
    }
	
    //这里计算将上面隐层所得到的输入(ac值)经过sigmoid函数的映射结果
    for (a=0; a<layer1_size; a++) {
		//为数值稳定,将ac值大小限制在[-50,50]
		//论文中有提到模型的参数小一些泛化的结果好一些
		if (neu1[a].ac>50) neu1[a].ac=50;  
        if (neu1[a].ac<-50) neu1[a].ac=-50;  
        val=-neu1[a].ac;
		
		//fasterexp函数在fasexp.h中实现,应该比math.h中的exp快吧
        neu1[a].ac=1/(1+fasterexp(val));		//sigmoid函数即1/(1+e^(-x))
    }
    
    if (layerc_size>0) {
		
		//计算隐层到压缩层的结果
		matrixXvector(neuc, neu1, syn1, layer1_size, 0, layerc_size, 0, layer1_size, 0);
		
		//和上面类似，这里计算的是压缩层
		for (a=0; a<layerc_size; a++) {
			if (neuc[a].ac>50) neuc[a].ac=50;  //for numerical stability
			if (neuc[a].ac<-50) neuc[a].ac=-50;  //for numerical stability
			val=-neuc[a].ac;
			neuc[a].ac=1/(1+fasterexp(val));
		}
    }
	
    //1->2 class
	//输出层class_size部分ac值置0
    for (b=vocab_size; b<layer2_size; b++) neu2[b].ac=0;
    
	//计算压缩层到class层(输出层的一部分)
    if (layerc_size>0) {
		matrixXvector(neu2, neuc, sync, layerc_size, vocab_size, layer2_size, 0, layerc_size, 0);
    }
    else
    {
		//无压缩层,直接计算隐层到输出层
		matrixXvector(neu2, neu1, syn1, layer1_size, vocab_size, layer2_size, 0, layer1_size, 0);
    }

另外一个要说明的是最大熵模型，rnn结合了最大熵模型，直观的看上去是输入层与输出层连接了起来（虽然作者总是这么说，但我总觉的不能叫输入层和输出层连接起来，中间有过渡）。我们先看一下从神经网络的视角去看一个最大熵模型，这个神经网络就是没有隐层而已，其他和三层结构的一样，并且学习算法也是一样的。如下图：

这是以二元模型为特征的最大熵模型,图是神经网络的角度看待的,无隐层,可以看到,如果是以三元模型为特征,那么输入层大小就是|V|^2, 并且任意一个时刻其中的神经元的激活值只可能有一个值为1，其余都是0。从这里面我们可以看到输入层中对应的任意一个历史特征，只有某个对应的神经值为1（记作第i个神经元），那么输出层的某个神经元激活值(记作第j个)就只与权值W中的第i列有关，某种程度由于输入层是1-of-V编码方式，我们可以认为一个特定的特征它所对应的参数就是W中某列，这一点就会RNN+ME中的基于哈希的实现中谈到。

//最大熵模型n元特征计算
    if (direct_size>0) {
		//注意这是hash定义在if内的,也就是出了if外面就无法访问了
		//下面会看到每次都单独定义了局部的hash
		//hash[i]里面存放的是i+1元模型的特征在syn_d中对应的下标
		unsigned long long hash[MAX_NGRAM_ORDER];	//this will hold pointers to syn_d that contains hash parameters
		
		for (a=0; a<direct_order; a++) hash[a]=0;
		
		//下面就是将n元特征单独映射为一个值,这里的权值是针对class部分的
		for (a=0; a<direct_order; a++) {
			b=0;
			if (a>0) if (history[a-1]==-1) break;	//if OOV was in history, do not use this N-gram feature and higher orders
			hash[a]=PRIMES[0]*PRIMES[1];
			
			for (b=1; b<=a; b++) hash[a]+=PRIMES[(a*PRIMES[b]+b)%PRIMES_SIZE]*(unsigned long long)(history[b-1]+1);	//update hash value based on words from the history
			
			//ME中对class的权值是在syn_d的前半部分,见图
			hash[a]=hash[a]%(direct_size/2);		//make sure that starting hash index is in the first half of syn_d (second part is reserved for history->words features)
		}

我们看一下表示rnn中最大熵模型的存储结构，如下图：

我们把这段代码展开细走一下，假设direct_order = 3,并且没有OOV，如下：

		out loop 1st:
		a = 0; a < 4
		b = 0;
		hash[0]=PRIMES[0]*PRIMES[1] = 108641969 * 116049371;
		
			  inner loop 1st:
			  b = 1; b<=0
			  退出内循环
			  hash[0]=hash[0]%(direct_size/2)
		  
		out loop 2nd:
		a = 1; a < 4;
		b = 0;
		hash[1]=PRIMES[0]*PRIMES[1] = 108641969 * 116049371;
		
			  inner loop 1st:
			  b = 1; b <= 1;
			  hash[a]= hash[a] + PRIMES[(a*PRIMES[b]+b)%PRIMES_SIZE]*(unsigned long long)(history[b-1]+1)
			  = hash[1] + PRIMES[(1*PRIMES[1]+1)%36]*(history[0]+1);
			  退出内循环
			  hash[1]=hash[1]%(direct_size/2);
			  
		out loop 3rd:
		a = 2; a < 4;
		b = 0;
		hash[2]=PRIMES[0]*PRIMES[1] = 108641969 * 116049371;
		
			  inner loop 1st:
			  b = 1; b <= 2;
			  hash[2]= hash[2] + PRIMES[(2*PRIMES[1]+1)%36]*(history[0]+1);
			  
			  inner loop 2nd:
			  b = 2; b <= 2;
			  hash[2]= hash[2] + PRIMES[(2*PRIMES[2]+2)%PRIMES_SIZE]*(history[1]+1)
			  退出内循环

大概能看出，hash[i]表示i+1元模型的历史映射，因为在计算hash[i]时，考虑了history[0..i-1], 这个映射结果是作为syn_d数组的下标,i+1元词作为特征与输出层的连接真正的参数值在syn_d中。最后把这个函数剩下的部分贴出来，后面以注释为主了。如下：

		//ME部分,计算在class层的概率分布,即P(c i |s(t))
		for (a=vocab_size; a<layer2_size; a++) {
			for (b=0; b<direct_order; b++) if (hash[b]) {
				neu2[a].ac+=syn_d[hash[b]];		//apply current parameter and move to the next one
				
				//这里解释一下,i+1元特征与输出层所连接的参数是放在syn_d中
				//是连续的,这里连续的长度分两种情况,一种是对class计算的,有class_size的长度
				//另一种是对word的，连续的长度是word所对应类别的词数
				//后面类似的代码同理
				hash[b]++;		//todo
			} else break;
		}
    }
	
    //activation 2   --softmax on classes
    // 20130425 - this is now a 'safe' softmax
	
	//这里softmax归一概率
	//这种方式主要是防止溢出,比如当ac值过大,exp(ac)可能就会溢出
    sum=0;
    real maxAc=-FLT_MAX;		//FLT_MAX表示float最大值
    for (a=vocab_size; a<layer2_size; a++)
        if (neu2[a].ac>maxAc) maxAc=neu2[a].ac; //this prevents the need to check for overflow
		for (a=vocab_size; a<layer2_size; a++)
			sum+=fasterexp(neu2[a].ac-maxAc);
		for (a=vocab_size; a<layer2_size; a++)
			neu2[a].ac=fasterexp(neu2[a].ac-maxAc)/sum; 
		
		if (gen>0) return;	//if we generate words, we don't know what current word is -> only classes are estimated and word is selected in testGen()
		
		
		//1->2 word
		
		if (word!=-1) {
			//置word所在类别的所有词的ac值为0
			for (c=0; c<class_cn[vocab[word].class_index]; c++) neu2[class_words[vocab[word].class_index][c]].ac=0;
			
			//计算待预测词的概率分布,这个概率分布是在word所在类别中的词上的
			if (layerc_size>0) {
				//word所在类别的词与压缩层的计算
				matrixXvector(neu2, neuc, sync, layerc_size, class_words[vocab[word].class_index][0], class_words[vocab[word].class_index][0]+class_cn[vocab[word].class_index], 0, layerc_size, 0);
			}
			else
			{
				//word所在类别的词与隐层的计算
				matrixXvector(neu2, neu1, syn1, layer1_size, class_words[vocab[word].class_index][0], class_words[vocab[word].class_index][0]+class_cn[vocab[word].class_index], 0, layer1_size, 0);
			}
		}
		
		//apply direct connections to words
		if (word!=-1) if (direct_size>0) {
			
			//ME中计算n元模型特征,这个是在word上的
			unsigned long long hash[MAX_NGRAM_ORDER];
			
			for (a=0; a<direct_order; a++) hash[a]=0;
			
			for (a=0; a<direct_order; a++) {
				b=0;
				if (a>0) if (history[a-1]==-1) break;
				hash[a]=PRIMES[0]*PRIMES[1]*(unsigned long long)(vocab[word].class_index+1);
				
				for (b=1; b<=a; b++) hash[a]+=PRIMES[(a*PRIMES[b]+b)%PRIMES_SIZE]*(unsigned long long)(history[b-1]+1);
				hash[a]=(hash[a]%(direct_size/2))+(direct_size)/2;
			}
			
			//计算ME部分,待预测词的概率分布,这个概率分布是在word所在类别中的词上的
			for (c=0; c<class_cn[vocab[word].class_index]; c++) {
				a=class_words[vocab[word].class_index][c];
				
				//这里的代码细节和上面是类似的
				for (b=0; b<direct_order; b++) if (hash[b]) {
					neu2[a].ac+=syn_d[hash[b]];
					hash[b]++;
					hash[b]=hash[b]%direct_size;
				} else break;
			}
		}
		
		//activation 2   --softmax on words
		// 130425 - this is now a 'safe' softmax
		
		//这里的归一概率和上面也是一样
		sum=0;
		if (word!=-1) { 
			maxAc=-FLT_MAX;
			for (c=0; c<class_cn[vocab[word].class_index]; c++) {
				a=class_words[vocab[word].class_index][c];
				if (neu2[a].ac>maxAc) maxAc=neu2[a].ac;
			}
			for (c=0; c<class_cn[vocab[word].class_index]; c++) {
				a=class_words[vocab[word].class_index][c];
				sum+=fasterexp(neu2[a].ac-maxAc);
			}
			for (c=0; c<class_cn[vocab[word].class_index]; c++) {
				a=class_words[vocab[word].class_index][c];
				neu2[a].ac=fasterexp(neu2[a].ac-maxAc)/sum; //this prevents the need to check for overflow
			}
		}
}

由于这个函数无奈的被分乱了，必须连起来一起看才行，所以最后把这个函数完整的带注释的放在下面：

//网络前向,计算概率分布
void CRnnLM::computeNet(int last_word, int word)
{
	//last_word表示当前输入层所在的词
	//word表示要预测的词
    int a, b, c;
    real val;
    double sum;   //sum is used for normalization: it's better to have larger precision as many numbers are summed together here
    
	//将last_word对应的神经元ac值为1,也可以看做是对该词的1-of-V的编码
    if (last_word!=-1) neu0[last_word].ac=1;
	
    //下面计算输入到隐层的部分
    for (a=0; a<layer1_size; a++) neu1[a].ac=0;
    for (a=0; a<layerc_size; a++) neuc[a].ac=0;
    
	//这里计算的是s(t-1)与syn0的乘积
    matrixXvector(neu1, neu0, syn0, layer0_size, 0, layer1_size, layer0_size-layer1_size, layer0_size, 0);
	
	//这里计算将last_word编码后的向量(大小是vocab_size,分量只有一个为1,其余为0)与syn0的乘积
    for (b=0; b<layer1_size; b++) {
        a=last_word;
        if (a!=-1) neu1[b].ac += neu0[a].ac * syn0[a+b*layer0_size].weight;
    }
	
    //这里计算将上面隐层所得到的输入(ac值)经过sigmoid函数的映射结果
    for (a=0; a<layer1_size; a++) {
		//为数值稳定,将ac值大小限制在[-50,50]
		//论文中有提到模型的参数小一些泛化的结果好一些
		if (neu1[a].ac>50) neu1[a].ac=50;  
        if (neu1[a].ac<-50) neu1[a].ac=-50;  
        val=-neu1[a].ac;
		
		//fasterexp函数在fasexp.h中实现,应该比math.h中的exp快吧
        neu1[a].ac=1/(1+fasterexp(val));		//sigmoid函数即1/(1+e^(-x))
    }
    
    if (layerc_size>0) {
		
		//计算隐层到压缩层的结果
		matrixXvector(neuc, neu1, syn1, layer1_size, 0, layerc_size, 0, layer1_size, 0);
		
		//和上面类似，这里计算的是压缩层
		for (a=0; a<layerc_size; a++) {
			if (neuc[a].ac>50) neuc[a].ac=50;  //for numerical stability
			if (neuc[a].ac<-50) neuc[a].ac=-50;  //for numerical stability
			val=-neuc[a].ac;
			neuc[a].ac=1/(1+fasterexp(val));
		}
    }
	
    //1->2 class
	//输出层class_size部分ac值置0
    for (b=vocab_size; b<layer2_size; b++) neu2[b].ac=0;
    
	//计算压缩层到class层(输出层的一部分)
    if (layerc_size>0) {
		matrixXvector(neu2, neuc, sync, layerc_size, vocab_size, layer2_size, 0, layerc_size, 0);
    }
    else
    {
		//无压缩层,直接计算隐层到输出层
		matrixXvector(neu2, neu1, syn1, layer1_size, vocab_size, layer2_size, 0, layer1_size, 0);
    }
	
    //最大熵模型n元特征计算
    if (direct_size>0) {
		//注意这是hash定义在if内的,也就是出了if外面就无法访问了
		//下面会看到每次都单独定义了局部的hash
		//hash[i]里面存放的是i+1元模型的特征在syn_d中对应的下标
		unsigned long long hash[MAX_NGRAM_ORDER];	//this will hold pointers to syn_d that contains hash parameters
		
		for (a=0; a<direct_order; a++) hash[a]=0;
		
		//下面就是将n元特征单独映射为一个值,这里的权值是针对class部分的
		for (a=0; a<direct_order; a++) {
			b=0;
			if (a>0) if (history[a-1]==-1) break;	//if OOV was in history, do not use this N-gram feature and higher orders
			hash[a]=PRIMES[0]*PRIMES[1];
			
			for (b=1; b<=a; b++) hash[a]+=PRIMES[(a*PRIMES[b]+b)%PRIMES_SIZE]*(unsigned long long)(history[b-1]+1);	//update hash value based on words from the history
			
			//ME中对class的权值是在syn_d的前半部分,见图
			hash[a]=hash[a]%(direct_size/2);		//make sure that starting hash index is in the first half of syn_d (second part is reserved for history->words features)
		}
		
		/*我们把这段代码展开细走一下，假设direct_order = 3,并且没有OOV
		out loop 1st:
		a = 0; a < 4
		b = 0;
		hash[0]=PRIMES[0]*PRIMES[1] = 108641969 * 116049371;
		
			  inner loop 1st:
			  b = 1; b<=0
			  退出内循环
			  hash[0]=hash[0]%(direct_size/2)
		  
		out loop 2nd:
		a = 1; a < 4;
		b = 0;
		hash[1]=PRIMES[0]*PRIMES[1] = 108641969 * 116049371;
		
			  inner loop 1st:
			  b = 1; b <= 1;
			  hash[a]= hash[a] + PRIMES[(a*PRIMES[b]+b)%PRIMES_SIZE]*(unsigned long long)(history[b-1]+1)
			  = hash[1] + PRIMES[(1*PRIMES[1]+1)%36]*(history[0]+1);
			  退出内循环
			  hash[1]=hash[1]%(direct_size/2);
			  
		out loop 3rd:
		a = 2; a < 4;
		b = 0;
		hash[2]=PRIMES[0]*PRIMES[1] = 108641969 * 116049371;
		
			  inner loop 1st:
			  b = 1; b <= 2;
			  hash[2]= hash[2] + PRIMES[(2*PRIMES[1]+1)%36]*(history[0]+1);
			  
			  inner loop 2nd:
			  b = 2; b <= 2;
			  hash[2]= hash[2] + PRIMES[(2*PRIMES[2]+2)%PRIMES_SIZE]*(history[1]+1)
			  退出内循环
					
		大概能看出，hash[i]表示i+1元模型的历史映射，因为在计算hash[i]时，考虑了history[0..i-1]
					  这个映射结果是作为syn_d数组的下标,i+1元词作为特征与输出层的连接真正的参数值在syn_d中
		*/	
		
		//ME部分,计算在class层的概率分布,即P(c i |s(t))
		for (a=vocab_size; a<layer2_size; a++) {
			for (b=0; b<direct_order; b++) if (hash[b]) {
				neu2[a].ac+=syn_d[hash[b]];		//apply current parameter and move to the next one
				
				//这里解释一下,i+1元特征与输出层所连接的参数是放在syn_d中
				//是连续的,这里连续的长度分两种情况,一种是对class计算的,有class_size的长度
				//另一种是对word的，连续的长度是word所对应类别的词数
				//后面类似的代码同理
				hash[b]++;		//todo
			} else break;
		}
    }
	
    //activation 2   --softmax on classes
    // 20130425 - this is now a 'safe' softmax
	
	//这里softmax归一概率
	//这种方式主要是防止溢出,比如当ac值过大,exp(ac)可能就会溢出
    sum=0;
    real maxAc=-FLT_MAX;		//FLT_MAX表示float最大值
    for (a=vocab_size; a<layer2_size; a++)
        if (neu2[a].ac>maxAc) maxAc=neu2[a].ac; //this prevents the need to check for overflow
		for (a=vocab_size; a<layer2_size; a++)
			sum+=fasterexp(neu2[a].ac-maxAc);
		for (a=vocab_size; a<layer2_size; a++)
			neu2[a].ac=fasterexp(neu2[a].ac-maxAc)/sum; 
		
		if (gen>0) return;	//if we generate words, we don't know what current word is -> only classes are estimated and word is selected in testGen()
		
		
		//1->2 word
		
		if (word!=-1) {
			//置word所在类别的所有词的ac值为0
			for (c=0; c<class_cn[vocab[word].class_index]; c++) neu2[class_words[vocab[word].class_index][c]].ac=0;
			
			//计算待预测词的概率分布,这个概率分布是在word所在类别中的词上的
			if (layerc_size>0) {
				//word所在类别的词与压缩层的计算
				matrixXvector(neu2, neuc, sync, layerc_size, class_words[vocab[word].class_index][0], class_words[vocab[word].class_index][0]+class_cn[vocab[word].class_index], 0, layerc_size, 0);
			}
			else
			{
				//word所在类别的词与隐层的计算
				matrixXvector(neu2, neu1, syn1, layer1_size, class_words[vocab[word].class_index][0], class_words[vocab[word].class_index][0]+class_cn[vocab[word].class_index], 0, layer1_size, 0);
			}
		}
		
		//apply direct connections to words
		if (word!=-1) if (direct_size>0) {
			
			//ME中计算n元模型特征,这个是在word上的
			unsigned long long hash[MAX_NGRAM_ORDER];
			
			for (a=0; a<direct_order; a++) hash[a]=0;
			
			for (a=0; a<direct_order; a++) {
				b=0;
				if (a>0) if (history[a-1]==-1) break;
				hash[a]=PRIMES[0]*PRIMES[1]*(unsigned long long)(vocab[word].class_index+1);
				
				for (b=1; b<=a; b++) hash[a]+=PRIMES[(a*PRIMES[b]+b)%PRIMES_SIZE]*(unsigned long long)(history[b-1]+1);
				hash[a]=(hash[a]%(direct_size/2))+(direct_size)/2;
			}
			
			//计算ME部分,待预测词的概率分布,这个概率分布是在word所在类别中的词上的
			for (c=0; c<class_cn[vocab[word].class_index]; c++) {
				a=class_words[vocab[word].class_index][c];
				
				//这里的代码细节和上面是类似的
				for (b=0; b<direct_order; b++) if (hash[b]) {
					neu2[a].ac+=syn_d[hash[b]];
					hash[b]++;
					hash[b]=hash[b]%direct_size;
				} else break;
			}
		}
		
		//activation 2   --softmax on words
		// 130425 - this is now a 'safe' softmax
		
		//这里的归一概率和上面也是一样
		sum=0;
		if (word!=-1) { 
			maxAc=-FLT_MAX;
			for (c=0; c<class_cn[vocab[word].class_index]; c++) {
				a=class_words[vocab[word].class_index][c];
				if (neu2[a].ac>maxAc) maxAc=neu2[a].ac;
			}
			for (c=0; c<class_cn[vocab[word].class_index]; c++) {
				a=class_words[vocab[word].class_index][c];
				sum+=fasterexp(neu2[a].ac-maxAc);
			}
			for (c=0; c<class_cn[vocab[word].class_index]; c++) {
				a=class_words[vocab[word].class_index][c];
				neu2[a].ac=fasterexp(neu2[a].ac-maxAc)/sum; //this prevents the need to check for overflow
			}
		}
}

Recurrent neural network language modeling toolkit 源码走读(六)

原文：http://blog.csdn.net/a635661820/article/details/44803071

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)