中文分词

Posted 2020-10-29 fxh1314

算法

　　正向最大匹配法；

　　基于最大概率分词方法

数据结构

　　在本次实验中最重要的事情就是建立合理的字典的索引结构，使得查询的速度、存储的空间需求达到较好的性能。
　　通过观察字典内容可知，存在多个词语有相同前缀的情况，而且数目是比较多的。如果按照直观的思想，直接将所有的词语保存在一个数据组中以供检索时候使用，势必造成
巨大的内存资源浪费，其二还会降低检索的效率。
对于词典中的数据采用词典树来保存时比较好的数据结构，它比较好的解决了公共前缀的困扰。但是存在一个问题，即从根到所有终止节点所代表的词语不一定是词典中的数
据。这里我们通过在节点中增添一个flag标志位来解决这个问题。
　　词典树结构定义如下：

private String str;// 保存词的内容
private int frequency = -1;//频率
private double probability=-1;//出现的概率
private int flag;//标记从跟到此节点的字符串是否是字典词
private Map<String, Tree> children;//孩子序列

　　注意：这里的private int frequency = -1;//频率 private double probability=-1;//出现的概率 private int flag;//标记从跟到此节点的字符串是否是字典词 三个属性在正向最大匹配时没有用到，这是在基于最概率大方法中所需要的。

算法实现

正向最大匹配算法：

　　正向最大匹配算法的要求：应该尽可能的将词语划分最大的长度。即应该按照字典中的顺序应该从最大长度的词语开始查起，匹配则划分，不匹配则长度减一，继续查找，直
到匹配长度为1（存在则为字典单字，不存在为非字典字）或者找到匹配为止（长度大于1的词典词）。
　　在词典树的数据结构中，不需要从最长的词语开始查找。因为字典中所有的词都是从树的根节点开始的，到树中的某一个节点停止。我们要做就是尽可能的向下遍历节点，当
到达叶节点或者找不到对应的节点时，应该回溯查找已经存在的最长词的划分。（详见代码），然后进行从头的再次开始查找。

基于最大概率的中文分词：

　　基本思想：

　　最大概率分词就是要求得 Max(P(w1|s),P(w2|s)) 。根据贝叶斯公式：P(w|s)=P(s|w)P(w)/P(s)（公式1）。在公式1中，因为P(s)和P(w|s)都基本一样，因此，就求最大的P(w)即可。根据一元语法，词之间出现的概率互相独立，因此有下面的公式成立： P(w)=P(w1,w2,…,w3)=P(w1)P(w2)…P(w3)即字符串出现的概率就是构成字符串的各个词的概率之积。
　　而一个词的概率可以按照其出现的次数除以语料中总的词数得到。在实际操作中可以发现P(w)与log(p(w))具有相同的性质（增大而增大）。我们可以将判断的依据改为使得log(w)=log(p(w1))+……+log(p(wn))的最大值，这样我们就将所求的问题转化为和最大的问题。
　　如果我们将p(w)定义为p(w)=总频数/频数。这样我们判断的依据就是使得：log(w)=log(p(w1))+……+log(p(wn))最小的组合。
　　至此，我们已经将问题转化为在图结构中的最短路径问题。图的顶点是句子中出现的词典词语，权值是相对的log(p(w))。

　　算法步骤：

　　1：构造字典树；

　　2：构造图结构；

　　3：寻找最短路径;

　　4:输出结果

　　算法存在的问题：

　　1：构成句子的所有字都必须出现在词典词典中，否则算法出错。

　　2：由于在求最短路径时，需要分配NN的数组，所有对于大规模的文本可能出现内存不足的错误情况。

实验结果：

　　正向最大匹配：

　　输入：
　　

str="一下子一九七二年"

输出：

str="一下子/一九七二年"

最大概率分析的结果：

使用的字典实例：

20 //词频的总数
今 1 //词的频率
天 1
雨 1
今天 12
下雨 3
天下 2

测试句子：

 str="今天下雨"

字母相对应的频数（代替log(p(w))）：

 

输出结果：

今天/下雨

代码：

完整代码详见：

 

https://github.com/BFH1122/Chinese_Seg

 

正向最大匹配法

　　构造字典树：

package com;

import java.util.HashMap;
import java.util.Map;

public class Tree {
    private String str;//
    private int frequency = -1;//频率
    private double  probability=-1;//出现的概率
    
    private int flag;//标记从跟到此节点的字符串是否是字典词
    private Map<String, Tree> children;//孩子序列
    
    
    public int getFlag() {
        return flag;
    }
    public void setFlag(int flag) {
        this.flag = flag;
    }
    public String getStr() {
        return str;
    }
    public void setStr(String str) {
        this.str = str;
    }
    public int getFrequency() {
        return frequency;
    }
    public void setFrequency(int frequency) {
        this.frequency = frequency;
    }
    public double getProbability() {
        return probability;
    }
    public void setProbability(double probability) {
        this.probability = probability;
    }    
    public void addChild(Tree node) {  
         if (children == null) {  
             children = new HashMap<String, Tree>();  
         }  
           
         if (!children.containsKey(node.getStr())) {  
             children.put(node.getStr(), node);  
         }
     }
    
     public Tree getChild(String ch) {  
         if (children == null || !children.containsKey(ch)) {  
             return null;  
         }  
           
         return children.get(ch);  
     }  
     
     public Map<String,Tree> getAllChilden()
     {
         return this.children;
     }
     
     public void removeChild(String ch) {  
         if (children == null || !children.containsKey(ch)) {  
             return;  
         }  
         children.remove(ch);  
     }  
}

分析算法：

package com;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class Latex {
    public int Max=999999;
    private Tree root=null;
    
    public Latex(String file) throws IOException
    {
        BuildTree(file);
    }
    
    public void Print() {
    }
    //图的节点的属性
    public class Node{
        public int id;
        public String str;//保r存节点上的字符
        public double cost;
        public String pro_str;
        public String next_str;
    }
    
    public Tree getNodeByWord(String word) {  
          if (root == null) {  
              System.out.println("发生错误！");
              return null;  
          }  
          Tree node = root;  
          for (int i = 0; i < word.length(); i++) {  
              String ch = word.charAt(i) + "";  
              if (node == null) {  
                  break;  
              } else {  
                  node = node.getChild(ch);  
              }  
          }  
            
          return node;  
      }  
    
    public List<Node> BuildTu(String sentence)
    {
        List<Node> Segs = new ArrayList<Node>(); 
        
        Node start_node=new Node();
        start_node.pro_str="-1";
        start_node.next_str="-1";
        start_node.id=0;
        start_node.str="start";
        Segs.add(start_node);
        int tmp_id=0;
        
        for (int i = 0; i < sentence.length(); i++) {  
            for (int j = i + 1; j <= sentence.length(); j++) {  
                String word = sentence.substring(i, j);  
                Tree tmp_node = this.getNodeByWord(word);  
                if (tmp_node == null) {  
                    break;  
                }  
                if (tmp_node.getFrequency() <= 0) {  
                    continue;  
                }  
                Node seg = new Node();  
                seg.str = word;
                seg.id=tmp_id++;
                seg.next_str = word.substring(word.length() - 1, word.length());  
                if (i == 0) {  
                    seg.pro_str="-1";  
                } else {  
                    seg.pro_str = sentence.substring(i - 1, i);  
                }  
                seg.cost = tmp_node.getProbability();  
                Segs.add(seg);  
            }  
        }

        Node end_node=new Node();
        end_node.id=tmp_id++;
        end_node.cost=1;
        end_node.pro_str=sentence.substring(sentence.length()-1,sentence.length());
        end_node.next_str="-1";
        end_node.str="end";
        Segs.add(end_node);
        return Segs;
    }
    //
    public void search_path(List<Node> Segs)
    {
        
        if(Segs.size()==0)
            return;
        int N=Segs.size();
        double COST[][]=new double[N][N];
        
        for(int i=0;i<N;i++)
        {
            for(int j=0;j<N;j++)
                COST[i][j]=Max;//初始化为最大值
        }
        
        for(int i=0;i<N;i++)
        {
            Node tmp_node=Segs.get(i);
            for(int j=0;j<N;j++)
            {
                Node ttmp=Segs.get(j);
                if(tmp_node.next_str.equals(ttmp.pro_str))
                {
                    COST[i][j]=ttmp.cost;
//                    System.out.println(tmp_node.str+"  "+i+"->"+j+"  "+ttmp.str);
                }
            }
        }
        
        int dex_path[]=new int[N];
        dex_path[0]=-1;
        String path[]=new String[N];
        for(int i=1;i<N;i++)
        {
            dex_path[i]=0;
        }
        
         List<Integer> S = new ArrayList<Integer>();
         S.add(0);
         List<Integer> T=new ArrayList<Integer>();
         double distance[]=new double[N];
         for(int i=1;i<N;i++)
         {
             T.add(i);
             if(COST[0][i]<Max)
                 distance[i]=COST[0][i];
             else
                 distance[i]=Max;
         }
         while(!T.isEmpty())
         {
             double min=distance[T.get(0)];
             int k=T.get(0);
             int kk=0;
             for(int i=0;i<T.size();i++)
             {
                 if(distance[T.get(i)]<min)
                 {
                     min=distance[T.get(i)];
                     k=T.get(i);
                     kk=i;
                 }
             }
             
             T.remove(kk);
             //更改权值
             for(int i=0;i<N;i++)
             {
                 if(distance[i]>distance[k]+COST[k][i])
                 {
                     distance[i]=distance[k]+COST[k][i];
                     dex_path[i]=k;
                 }
             }
             
        }
        
        String path_str="";
        
        int x=dex_path[N-1];
        while(x!=-1)
        {
            path_str=Segs.get(x).str+"/"+path_str;
            x=dex_path[x];
        }
        System.out.println(path_str.substring(6,path_str.length()));
    }
    
    //依概率的方式进行分析
    public String Latex_str(String str)
    {
        String result="";
        search_path(BuildTu(str));
        return result;
    }
    //建立字典树
    public void BuildTree(String file_name) throws IOException
    {
        root=new Tree();
          File file = new File(file_name);  
          BufferedReader in = new BufferedReader(  
                  new InputStreamReader(new FileInputStream(file), "utf-8"));//???????
        
          String line = in.readLine();//读入第一行，是词典词的总频数  
          
          int totalFreq = Integer.parseInt(line);
          
          while((line=in.readLine())!=null)
          {
              
              Tree node=root;
              String[] segs = line.split("\\t");
              String word = segs[0];
              int freq=-1;
              freq = Integer.parseInt(segs[1]);//读取词频
              
              for(int i=0;i<word.length();i++)
              {
                  char ch=word.charAt(i);
                  Tree tmp_node=node.getChild(""+ch);
                  if(tmp_node==null)
                  {
                      tmp_node=new Tree();
                      tmp_node.setStr(ch+"");
                      node.addChild(tmp_node);
                  }
                  node=tmp_node;
              }
              node.setFlag(1);
              node.setFrequency(freq);
              node.setProbability(Math.log((double)totalFreq / freq));
          }
          in.close();
    }
}