概率算法

很多算法的每一个计算步骤都是固定的，而在下面我们要讨论的概率算法，允许算法在执行的过程中随机选择下一个计算步骤。许多情况下，当算法在执行过程中面临一个选择时，随机性选择常比最优选择省时。因此概率算法可在很大程度上降低算法的复杂度。

概率算法的一个基本特征是对所求解问题的同一实例用同一概率算法求解两次可能得到完

全不同的效果。这两次求解问题所需的时间甚至所得到的结果可能会有相当大的差别。一般情况下，可将概率算法大致分为四类:数值概率算法，蒙特卡罗（Monte Carlo）算法，拉斯维加斯（Las Vegas）算法和舍伍德（Sherwood）算法。

数值概率算法常用于数值问题的求解。这类算法所得到的往往是近似解。而且近似解的精度随计算时间的增加不断提高。在许多情况下，要计算出问题的精确解是不可能或没有必要的，因此用数值概率算法可得到相当满意的解。

蒙特卡罗算法用于求问题的准确解。对于许多问题来说，近似解毫无意义。例如，一个判定问题其解为“是”或“否”，二者必居其一，不存在任何近似解答。又如，我们要求一个整数的因子时所给出的解答必须是准确的，一个整数的近似因子没有任何意义。用蒙特卡罗算法能求得问题的一个解，但这个解未必是正确的。求得正确解的概率依赖于算法所用的时间。算法所用的时间越多，得到正确解的概率就越高。蒙特卡罗算法的主要缺点就在于此。一般情况下，无法有效判断得到的解是否肯定正确。

拉斯维加斯算法不会得到不正确的解，一旦用拉斯维加斯算法找到一个解，那么这个解肯定是正确的。但是有时候用拉斯维加斯算法可能找不到解。与蒙特卡罗算法类似。拉斯维加斯算法得到正确解的概率随着它用的计算时间的增加而提高。对于所求解问题的任一实例，用同一拉斯维加斯算法反复对该实例求解足够多次，可使求解失效的概率任意小。

舍伍德算法总能求得问题的一个解，且所求得的解总是正确的。当一个确定性算法在最坏情况下的计算复杂性与其在平均情况下的计算复杂性有较大差别时，可以在这个确定算法中引入随机性将它改造成一个舍伍德算法，消除或减少问题的好坏实例间的这种差别。舍伍德算法精髓不是避免算法的最坏情况行为，而是设法消除这种最坏行为与特定实例之间的关联性。

本文简要的介绍一下数值概率算法和舍伍德算法。

首先来谈谈随机数。随机数在概率算法设计中扮演着十分重要的角色。在现实计算机上无法产生真正的随机数，因此在概率算法中使用的随机数都是一定程度上随机的，即伪随机数。

产生随机数最常用的方法是线性同余法。由线性同余法产生的随机序列a1,a2,...,an满足

a0=d

an=(ban-1+c)mod m n=1,2.......

其中,b>=0, c>=0, d>=m。d称为该随机序列的种子。

下面我们建立一个随机数类RadomNumber，该类包含一个由用户初始化的种子randSeed。给定种子之后，既可产生与之相应的随机数序列。randseed是一个无符号长整型数，既可由用户指定也可由系统时间自动产生。

const unsigned long maxshort=65536L;

const unsigned long multiplier=1194211693L;

const unsigned long adder=12345L;

class RandomNumber

{

private:

//当前种子

unsigned long randseed;

public:

//构造函数，缺省值0表示由系统自动产生种子

RandomNumber(unsigned long s=0);

//产生0-n-1之间的随机整数

unsigned short Random(unsigned long n);

//产生[0，1)之间的随机实数

double fRandom(void);

};

RandomNumber::RandomNumber(unsigned long s)

{

if(s==0)

randseed=time(0);

else

randseed=s;

}

unsigned short RandomNumber::Random(unsigned long n)

{

randseed=multiplier*randseed+adder;

return (unsigned short)((randseed>>16)%n);

}

double RandomNumber::fRandom(void)

{

return Random(maxshort)/double(maxshort);

}

函数Random在每次计算时，用线性同余式计算新的种子。它的高16位的随机性较好，将randseed右移16位得到一个0-65535之间的随机整数然后再将此随机整数映射到0-n-1范围内。

对于函数fRandom,先用Random(maxshort)产生一个0-(maxshort-1之间的整型随机序列)，将每个整型随机数除以maxshort，就得到[0，1）区间中的随机实数。

下面来看看数值概率算法的两个例子：

1.用随机投点法计算π

设有一半径为r的圆及其外切四边形，如图所示。向该正方形随机投掷n个点。设落入圆内的点在正方形上均匀分布，因而所投入点落入圆内的概率为πr^2/4r^2，所以当n足够大时，k与n之比就逼近这一概率，即π/4。由此可得使用随机投点法计算π值的数值概率算法。具体实现时，只需要在第一次象限计算即可。

double Darts(int n)

{

static RandomNumber dart;

int k=0;

for(int i=1;i<=n;i++){

double x=dart.fRandom();

double y=dart.fRandom();

if((x*x+y*y)<1)

k++;

}

return 4*k/double(n);

}

再简单举个舍伍德算法的例子。

我们在分析一个算法在平均情况下的计算复杂性时，通常假定算法的输入数据服从某一特定的概率分布。例如，在输入数据是均匀分布时，快速排序算法所需的平均时间是O(n logn)。但是如果其输入已经基本上排好序时，所用时间就大大增加了。此时，可采用舍伍德算法消除算法所需计算时间与输入实例间的这种联系。

在这里，我们用舍伍德型选择算法随机的选择一个数组元素作为划分标准。这样既能保证算法的线性时间平均性能又避免了计算拟中位数的麻烦。非递归的舍伍德型算法可描述如下：

template

Type select(Type a[], int l, int r, int k) {

static RandomNumber rnd;

while(true){

if(l>=r)

return a[l];

int i=l, j=l=rnd.Random(r-l+1);

Swap(a[i], a[j]);

j=r+1;

Type pivot=a[l];

while(true)

{

while(a[++i]

while(a[--j]>pivot);

if(i>=j)

break;

Swap(a[i], a[j]);

}

if(j-l+1==k)

return pivot;

a[l]=a[j];

a[j]=pivot;

if(j-l+1

{

k=k-j+l-1;

l=j+1;

}

else

r=j-1;

}

}

template

Type Select(Type a[], int n, int k)

{

if(k<1||k>n)

throw OutOfBounds();

return select(a, 0, n-1, k);

}

平时我们一般开始考虑的是一个有着很好平均性能的选择算法，但在最坏情况下对某些实例算法效率较低。这时候我们用概率算法，将上述算法改造成一个舍伍德型算法，使得该算法对任何实例均有效。

不过在有些情况下，所给的确定性算法无法直接改造成舍伍德型算法。这时候就可以借助随机预处理技术，不改变原有的确定性算法，仅对其输入进行随机洗牌，同样可以得到舍伍德算法的效果。还是刚才的例子，换一种方法实现：

template

void Shuffle(Type a[], int n)

{

static RandomNumber rnd;

for(int i=1;i

int j=rnd.Random(n-i)+i;

Swap(a[i], a[j]);

}

}

在上文里，我们对概率算法中的数值概率算法以及舍伍德算法举例作了简要的介绍，希望能使大家对概率算法有一个初步的认识，并且将这种思想运用到自己平时的编程中。

FileInputStream fin=new FileInputStream(sourceFile);

BufferedReader br=new BufferedReader(new InputStreamReader(fin));

String str=br.readLine();

String[] s=str.split(" ");

TreeMap map = new TreeMap();

for (int i = 0; i < s.length; i++) {

String key = s[i].toLowerCase();

if (s[i].length() > 1) {

if (map.get(key) == null) {

map.put(key, 1);

}

else {

int value = map.get(key).intValue();

value++;

map.put(key, value);

}

}

}

}

}

111111111111111111111

前几天读到google研究员吴军的数学之美系列篇，颇有感触。而恰好自己前段时间做了个基于统计语言模型的中文切分系统的课程项目，于是乎，帖出来与大家共同学习。

分词技术在搜索引擎，信息提取，机器翻译等领域的重要地位与应用就不敖述了。步入正题：）

一、项目概述

本切分系统的统计语料是用我们学校自己开放的那部分，大家可以在这里下载，中文字符约184万，当然这都是已切分好了的，可以用此建立一个比较小的语

料库。本系统我主要分下面四个步骤完成：

1、语料预处理

2、建立2-gram（统计二元模型）

3、实现全切分

4、评估测试

下面我分别对这四个方面一一道来。

1、语料预处理

下载的已切分的语料都是形如“19980131-04-012-001/m 现实/n 的/u 顿

悟/vn 却/d 被/p 描/v 出/v 形/Ng 来/v 。/w ” ，有的前面还保留了日期编号，因为这些切分语料的来源是人民日报。预处理主要是按标点符号分句，句子简单定义为（。？！：；）这五种标点符号结尾的词串，句子首尾分别添加和这两个表示句子开始和结束的标记，这在2-gram建模时要

用的，后面会提到。处理过程中，忽略词类信息和前面的日期信息，因为我这个切分系统不考虑词类标注。如前面这句预处理后应该为下面形式“现实

的顿悟却被描出形来。” ，当然切分词之间你可以用你想用的

符号标记，而不必是空格。因为考虑到所有的英文字符和数字的ASCII，我用了下面方法实现之：

out ; //输出流

in; //输入流

StringBuffer s1 = new StringBuffer(); //缓冲

char a = in.read();

while (a != -1) //判断是否已到流的终点

{

if ((a == '。' || a == '？' || a == '！' || a == '：' || a == '；' )) //一句结束{

String s2 = new String(s1);

out.write(""); //在句子前加

out.write(s2);

out.write(""); //在句子末尾加

out.write('/n'); //换行

s1 = new StringBuffer();

}

else if ( a == '/')

s1 = s1.append((char)32); //分词位置空格

else if (a > 256 )

s1 = s1.append((char)a);

a = in.read();

}

out.close();

in.close();

2、建立2-gram模型（统计二元模型）

在这里首先简单介绍一下n-gram模型和2-gram模型。

根据语言样本估计出的概率分布P就称为语言L的语言模型。对给定的句子s = w1w2…wn，（数字，n,i都为下标，wi为句子s的一个词）。由链式规则（Chain rule），P(s) = p(w1)p(w2|w1)p(w3|w1w2)……p(wn|w1w2w3…w(n-1)) , 对

p(wi|w1w2…w(i-1))而言，(w1w2…w(i-1))即为wi的历史。考虑前面n-1个词构成历史的模型即为n-gram模型。n越大，提供的语境信息也越多，但代价就越大，且需训练语料多；n较小时，提供的信息比较少，但计算代价小，且无需太多训练语料。

令c(w1,…，wi)表示词串w1,w2…wi在训练语料中出现的次数，则由最大似然估计，P(wn|w1,…,w(n-1)) = c(w1,…，wn) / c(w1,…，w(n-1)). 同理，则2-gram为P(wn|w(n-1)) = c(w(n-1),wn) / c(w(n-1)).

若想了解更多相关知识，大家找相关资料看看，随便把大学时的那本概率与统计课本拿出来翻翻，数学真是一个好东东：）

回归项目：）训练语料一共有5万多个不同的词。建立2-gram统计模型时不断要把每个词在训练语料中出现频率统计出来，还要把每个词及其后面的那个词组成的2-gram在训练语料中出现频率统计出来。因为在切分时会频繁的在建立的2-gram模型中查找相关的数据，所有，存储这个2-gram模型数据的数据结构一定要能提供高效的查找。故选择hash表，它能提供常数时间的查找。Java类库里提供了HashMap类，基于数据两还不是非常大，故可直接拿来用。在存储时，每一个key值对应一个在训练语料中出现过的词语，而每一个key

值对应的value值又是一个HashMap。暂且称为子hashmap.这个结构有点类似文件结构里的二级索引。其相关代码如下：

怎么在预处理文件里把词分别读出来就不罗嗦了，方法：每读入一行，按空格分成String数组，用个正则表达式匹配下即能得到。

//此方法传入的两个词组成一个2-gram，prewd为前一个词,currwd为紧随其后的词

public static void add(String prewd , String currwd){

String key = prewd;

String curr = currwd;

boolean bb = HMap.containsKey(key);

//Hmap是一个已存在的HashMap，用来存储2-gram统计模型。在这里判断preword 是否在主map 中

if (bb == false) { //若主map 中无，则添加

HashMap hm = new HashMap(); //首先，新构造一个子MAP

hm.put(key , new Integer(1)); //存储主KEY 的频率

hm.put(curr , new Integer(1)); //存储主KEY 后面紧接着的那个词频率

HMap.put(key,hm); //将主KEY 和对应的子MAP 放入主MAP 中

}

else //若主map 中含有该词

{

HashMap temp = (HashMap)HMap.get(key); //返回主KEY 所对应的子MAP ，进行值的修改

int count = ((Integer)temp.get(key)).intValue() + 1; //在子map 中将主key 次数加1

temp.put(key , new Integer(count));

if (temp.containsKey(curr))

//判断子map 中是否含有该词

{

int value =

((Integer)temp.get(curr)).intValue() + 1;

temp.put(curr , new Integer(value));

}

else

temp.put(curr, new Integer(1));

//若无，则将其存入子map

HMap.put(key , temp); //子map 修改完毕，将其重新放入主map

}

}

}

因为语言中的大部分词属于低频词，所以稀疏问题肯定存在。而MLE（最大似然估计）给在训练语料中没有出现的2-gram的赋给0概率。所以还得对2-gram 模型进行数据平滑，以期得到更好的参数。目前平滑技术比较多，如

Add-one,Add-delta,Witten-Bell，held-out留存平滑等。本系统主要采用了

Add-delta和held-out两中平滑方式，下面就Add-delta平滑技术为例，对2-gram 进行平滑。对2-gram模型，其平滑公式为：

P(wn|w(n-1)) = [c(w(n-1),wn) + delta ] / ( N + delta * V) ,这里去delta为0.5

其中，N：训练语料中所有的2-gram的数量

V：所有的可能的不同的2-gram的数量

平滑思路：1.产生主hashmap的迭代器iterator，依次读key;

2.对每一个key，又读出其value，即一个子hashmap;

3.然后根据平滑公式对子map里的值进行计算修改

算法框架：

Iterator it = 主hashmap.keySet().iterator();

While(it.hasNext())

{

主key = it.next();

子hashmap = (HashMap)主hashmap.get(主key);

Iterator itr = 子hashmap.keySet().iterator();

While(itr.hasNext())

{

根据平滑公式依次计算修改

}

}

注意问题：1.因为计算得出的概率值一般都比较小，为了防止出现下溢，可对其取对数，再取反。

2.每一个主key所对应的所有没有出现过的，即频率为零的

2-gram，统一用一个键值对存储在相应的子hashmap里即可。

完毕，对象序列化。使用该系统时，lazy load将其载入内存，然后可让其一直存活在内存，这会大大加快速度。

到此，2-gram模型建立完毕。

3、全切分实现

切词一般有最大匹配法（MM、RMM），基于规则的方法，基于统计的方法。关于前两者就不罗嗦了。所谓全切分就是要根据字典得到所以可能的切分形式。歧义识别的方法主要有：基于规则的方法和基于统计的方法。这里当然是采用基于2-gram统计模型的方法了：）为了避免切分后再进行歧义分析的时间浪费。并且这里采用边切分边评价的方法，即在切分进行的同时进行评价的方法。

对一个句子进行全切分的结果，即所以可能的组合，可以形成一棵解空间树

于是，可用回溯法搜索最优解

若将所有的全切分组合先搜索出来，然后再根据2-gram选择最佳，显然会很浪费时间，因为过程中可能存在很多的重复搜索,而回溯搜索的时间复杂度为指数时间

所以，在搜索过程中要结合剪枝，避免无效搜索，可很大提高效率

采用树的深度优先法则。可找到最优解

具体算法如下：

Stack.push(BOS) //树节点

while stack不为空

x=stack.pop()

pos：=x．Pos，w = x.w oldvalue：= x.value preword：

=x.preword

if m>O then //m为首词串的个数

forj：=1 to m do

FWj为fwc的第j个元素l

if length(w+FWj) =length(c)且概率最大then output w+FWjl且设置最新的句子最大概率值

else

posl：=pos+length(FWj)l

if probability(w+FWj，posl，

newsate)>maxValue(pos1)

stack.push(x)

endif

endfor

endif

endwhile

end．

在算法实现过程中需要考虑一些诸如树节点保存，首词串处理等问题。

4.评估测试

环境：windows XP2, AMD Athlon 1800+, Memory 768m，JDK1.5

Delta平滑：随着delta的取值变小，准确率上升，0.5，0.01，0.0001

召回率：0.9756 0.9826 0.9928

准确率：0.9638 0.9710 0.9883

留存平滑

召回率：0.9946

准确率：0.9902

一般情况下，留存平滑应该还是比delta平滑更好

所有建模过程及平滑过程在1分钟内都可完成。

切分时间与效率：

n 测试语料，17455字符，（中文17287），平均句长41个字，时间：340ms, 平均切分速度：5.1 万/S

n 20.5万测试语料（取自笑傲江湖），预处理后17.46万，时间110 MS,句子文本行数目24945，平均句长7 ，切分时间1300MS ，平均13.46 万/ 秒

n 20.5万测试语料（取自笑傲江湖），不预处理，平均句长239 ，切分时间40S，平均5000字/秒

回溯算法是时间开销为O(N!),所以在切分过程中句子长度直接决定了切分的速度,因为句子越长词越多

经过预处理，句子短，平均句长7, 回溯短，故速度要快很多。

到此，该系统基本完成，告一段落。感觉写的挺乱的呵呵

现在在做另一个作业，做个简单搜索引擎，准备把这个东东结合在搜索引擎里面，实现切分功能：）