中文分词

最新推荐文章于 2024-09-25 13:00:00 发布
最新推荐文章于 2024-09-25 13:00:00 发布
阅读量428 收藏
点赞数
分类专栏： 搜索引擎/lucene 文章标签： 中文分词算法 中文分词-java-demo 中文分词
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YABAJ/article/details/62435761
版权

分词策略

这里写图片描述
这里写图片描述

查找算法

对于一个庞大的达几十万的词典库，查询时间是衡量分词效率的重要指标，所以高效的查找算法是必须的。
通常来说，对于查找算法，在有序列表中查找比在无序列表中查找更快，分区查找比全局遍历要快。
通过查看ArrayList、LinkedList、HashSet的contains方法的源代码，发现ArrayList和LinkedList采用全局遍历的方式且未利用有序列表的优势，HashSet使用了分区查找，如果hash分布均匀冲突少，则需要遍历的列表就很少甚至不需要。
经过实际测试对比，对一段文字分词使用ArrayList耗时2113ms，而使用HashSet平均耗时23ms左右，几乎相差100倍。所以我使用了HashSet进行查词。

后来查资料发现有TRIE索引树算法可以使查询速度更快。虽然HashSet已经有不错的性能了，但是如果词典越来越大，内存占用越来越多怎么办？如果有一个数据结构，有接近HashSet性能的同时，又能对词典的数据进行压缩以减少内存占用，那就完美了。
首先自己实现一个Trie的数据结构，替换HashSet，经过多次测试并改进TrieNode结构后，实现了基于有序数组的二分查找算法，结果耗时稳定在15ms左右，可以发现结果比HashSet要用时短，而且内存占用也减少了。

上代码吧

public class ChineseSegment {
    // private static final List<String> DIC = new ArrayList<>();
    private static final HashSet<String> DIC = new HashSet<>();
    // private static final TrieIndex DIC = new TrieIndex();

    private static final HashSet<String> POINT = new HashSet<>();
    private static int MAX_LENGTH = 0;

    static {
        try {
            System.out.println("开始初始化词典");
            long start = System.currentTimeMillis();
            int max = 1;
            int count = 0;
            List<String> lines1 = Files.readAllLines(
                    Paths.get("D:/文档/课程/搜索引擎/实验/词典/chinese_stopword.txt"),
                    Charset.forName("utf-8"));
            List<String> lines2 = Files.readAllLines(
                    Paths.get("D:/文档/课程/搜索引擎/实验/词典/dic.txt"),
                    Charset.forName("utf-8"));
            List<String> lines3 = Files.readAllLines(
                    Paths.get("D:/文档/课程/搜索引擎/实验/词典/Stopword.txt"),
                    Charset.forName("utf-8"));
            List<String> lines4 = new ArrayList<String>();
            lines4.addAll(lines1);
            lines4.addAll(lines2);
            List<String> lines5 = new ArrayList<String>();
            lines5.addAll(lines3);
            List<String> lines = new ArrayList<String>(new HashSet(lines4));// 去重
            for (String line : lines) {
                DIC.add(line);
                count++;
                if (line.length() > max) {
                    max = line.length();
                }
            }
            List<String> _lines = new ArrayList<String>(new HashSet(lines5));
            for (String line : _lines) {
                POINT.add(line);
                count++;
                if (line.length() > max) {
                    max = line.length();
                }
            }
            MAX_LENGTH = max;

            System.out.println("完成初始化词典，词数目：" + count);
            System.out.println("最大分词长度：" + MAX_LENGTH);
            long end = System.currentTimeMillis();
            System.out.println("初始化词典结束");
            System.out.println("初始化词典耗时：" + (end - start) + "ms");
        } catch (IOException ex) {
            System.err.println("词典装载失败:" + ex.getMessage());
        }

    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        System.out.println("开始分词......");
        String text = "";
        StringBuffer sb = new StringBuffer("");
        try {
            List<String> lines = Files.readAllLines(
                    Paths.get("D:/文档/课程/搜索引擎/实验/词典/text.txt"),
                    Charset.forName("gbk"));
            for (String str : lines) {
                sb.append(str);
            }
            text = sb.toString();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("分词内容：" + text);

        // 分割标点
        text = segPoint(text);

        // 分词
        List<String> seg = seg(text);
        StringBuffer res_sb = new StringBuffer("");
        for (String str : seg) {
            res_sb.append(str);
        }
        long end = System.currentTimeMillis();
        System.out.println("分词结束");
        System.out.println("分词耗时：" + (end - start) + "ms");
        System.out.println("将段落分句后再分词");
        System.out.println(res_sb);
    }

    /**
     * 分割标点符号
     * 
     * @param text
     * @return
     */
    public static String segPoint(String text) {
        /* 正则表达式：句子结束符 */
        String regEx = "";
        StringBuffer sb = new StringBuffer("");
        for (String string : POINT) {
            sb.append(string);
        }
        regEx = "[" + SegUtils.escapeExprSpecialWord(sb.toString()) + "]";

        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(text);

        /* 按照句子结束符分割句子 */
        String[] substrs = p.split(text);

        /* 将句子结束符连接到相应的句子后 */
        if (substrs.length > 0) {
            int count = 0;
            while (count < substrs.length) {
                if (m.find()) {
                    String g = m.group();
                    substrs[count] += g + "\n";
                    // substrs[count] += g;
                }
                count++;
            }
        }
        StringBuffer res_sb1 = new StringBuffer("");
        for (int i = 0; i < substrs.length; i++) {
            res_sb1.append(substrs[i]);
        }
        text = res_sb1.toString();
        return text;

    }

    /**
     * 分词过程 逆向匹配
     * 
     * @param text
     * @return
     */
    public static List<String> seg(String text) {
        List<String> result = new ArrayList<>();
        // int len = MAX_LENGTH;
        int len = 4;
        boolean flagEnglish = false;
        boolean flagNumber = false;
        while (text.length() > 0) {

            if (text.length() < len) {
                len = text.length();
            }
            // 取指定的最大长度的文本去词典里面匹配
            String tryWord = text.substring(text.length() - len, text.length());
            while (!DIC.contains(tryWord) && !SegUtils.isNumber(tryWord)
                    && !SegUtils.isEnglish(tryWord)) {
                // 如果长度为一且在词典中未找到匹配，则按长度为一切分
                if (tryWord.length() == 1) {
                    break;
                }
                // 如果匹配不到，则减去第一个字继续匹配
                tryWord = tryWord.substring(1, tryWord.length());
            }
            if ("\n".equals(tryWord)) {
                result.add(0, tryWord);
            } else {
                if (SegUtils.isEnglish(tryWord)) {
                    if (!flagEnglish) {
                        result.add(0, tryWord + "]");
                        flagEnglish = true;
                    } else {
                        result.add(0, tryWord);
                    }
                } else if (SegUtils.isNumber(tryWord)) {
                    if (!flagNumber) {
                        result.add(0, tryWord + "]");
                        flagNumber = true;
                    } else {
                        result.add(0, tryWord);
                    }
                } else {
                    if (flagEnglish) {
                        result.add(0, "[" + tryWord + "][");
                        flagEnglish = false;
                    } else if (flagNumber) {
                        result.add(0, "[" + tryWord + "][");
                        flagNumber = false;
                    } else {
                        result.add(0, "[" + tryWord + "]");
                    }
                }
            }

            // 从待分词文本中去除已经分词的文本
            text = text.substring(0, text.length() - tryWord.length());
        }
        return result;
    }
}
/**
 * Trie前缀索引树， 用于查找一个指定的字符串是否在词典中
 * 
 * @author Administrator
 *
 */
public class TrieIndex {

    private final TrieNode ROOT_NODE = new TrieNode('/');

    public boolean contains(String item) {
        // 去掉首尾空白字符
        item = item.trim();
        int len = item.length();
        if (len < 1) {
            return false;
        }
        // 从根节点开始查找
        TrieNode node = ROOT_NODE;
        for (int i = 0; i < len; i++) {
            char character = item.charAt(i);
            TrieNode child = node.getChild(character);
            if (child == null) {
                // 未找到匹配节点
                return false;
            } else {
                // 找到节点，继续往下找
                node = child;
            }
        }
        if (node.isTerminal()) {
            return true;
        }
        return false;
    }

    public void addAll(List<String> items) {
        for (String item : items) {
            add(item);
        }
    }

    public void add(String item) {
        // 去掉首尾空白字符
        item = item.trim();
        int len = item.length();
        if (len < 1) {
            // 长度小于1则忽略
            return;
        }
        // 从根节点开始添加
        TrieNode node = ROOT_NODE;
        for (int i = 0; i < len; i++) {
            char character = item.charAt(i);
            TrieNode child = node.getChildIfNotExistThenCreate(character);
            // 改变顶级节点
            node = child;
        }
        // 设置终结字符，表示从根节点遍历到此是一个合法的词
        node.setTerminal(true);
    }

    private static class TrieNode implements Comparable {
        private char character;
        private boolean terminal;
        private TrieNode[] children = new TrieNode[0];

        public TrieNode(char character) {
            this.character = character;
        }

        public boolean isTerminal() {
            return terminal;
        }

        public void setTerminal(boolean terminal) {
            this.terminal = terminal;
        }

        public char getCharacter() {
            return character;
        }

        public void setCharacter(char character) {
            this.character = character;
        }

        public Collection<TrieNode> getChildren() {
            return Arrays.asList(children);
        }

        /**
         * 利用二分搜索算法从有序数组中找到特定节点
         * 
         * @param character待查找节点
         * @returnNULL or 节点数据
         */
        public TrieNode getChild(char character) {
            // for (TrieNode child : children) {
            // if (child.getCharacter() == character) {
            // return child;
            // }
            // }
            int index = Arrays.binarySearch(children, character);
            if (index >= 0) {
                return children[index];
            }
            return null;
        }

        public TrieNode getChildIfNotExistThenCreate(char character) {
            TrieNode child = getChild(character);
            if (child == null) {
                child = new TrieNode(character);
                addChild(child);
            }
            return child;
        }

        public void addChild(TrieNode child) {
            // children = Arrays.copyOf(children, children.length + 1);
            // this.children[children.length - 1] = child;
            children = insert(children, child);
        }

        /**
         * 将一个字符追加到有序数组
         * 
         * @param array
         *            有序数组
         * @param element
         *            字符
         * @return 新的有序数字
         */
        private TrieNode[] insert(TrieNode[] array, TrieNode element) {
            int length = array.length;
            if (length == 0) {
                array = new TrieNode[1];
                array[0] = element;
                return array;
            }
            TrieNode[] newArray = new TrieNode[length + 1];
            boolean insert = false;
            for (int i = 0; i < length; i++) {
                if (element.getCharacter() <= array[i].getCharacter()) {
                    // 新元素找到合适的插入位置
                    newArray[i] = element;
                    // 将array中剩下的元素依次加入newArray即可退出比较操作
                    System.arraycopy(array, i, newArray, i + 1, length - i);
                    insert = true;
                    break;
                } else {
                    newArray[i] = array[i];
                }
            }
            if (!insert) {
                // 将新元素追加到尾部
                newArray[length] = element;
            }
            return newArray;
        }

        @Override
        public int compareTo(Object o) {
            // TODO Auto-generated method stub
            return this.getCharacter() - (char) o;
        }
    }

    public void show() {
        show(ROOT_NODE, "");
    }

    private void show(TrieNode node, String indent) {
        if (node.isTerminal()) {
            System.out.println(indent + node.getCharacter() + "(T)");
        } else {
            System.out.println(indent + node.getCharacter());
        }
        for (TrieNode item : node.getChildren()) {
            show(item, indent + "\t");
        }
    }
}
public class SegUtils {

    /**
     * 转义正则特殊字符 （$()*+.[]?\^{},|）
     * 
     * @param keyword
     * @return
     */
    public static String escapeExprSpecialWord(String keyword) {
        if (!"".equals(keyword) || keyword != null) {
            String[] fbsArr = { "\\", "$", "(", ")", "*", "+", ".", "[", "]",
                    "?", "^", "{", "}", "|" };
            for (String key : fbsArr) {
                if (keyword.contains(key)) {
                    keyword = keyword.replace(key, "\\" + key);
                }
            }
        }
        return keyword;
    }

    // GENERAL_PUNCTUATION 判断中文的"号
    // CJK_SYMBOLS_AND_PUNCTUATION 判断中文的。号
    // HALFWIDTH_AND_FULLWIDTH_FORMS 判断中文的，号
    /**
     * 是否是中文
     * 
     * @param c
     * @return
     */
    public static boolean isChinese(char c) {
        Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
        if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
                || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
                || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
                || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION
                || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
                || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) {
            return true;
        }
        return false;
    }

    /**
     * 是否是英文
     * 
     * @param c
     * @return
     */
    public static boolean isEnglish(String charaString) {
        return charaString.matches("^[a-zA-Z]*");
    }

    public static boolean isChinese(String str) {
        String regEx = "[\\u4e00-\\u9fa5]+";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(str);
        if (m.find())
            return true;
        else
            return false;
    }

    public static boolean isNumber(String str) {
        String regEx = "^\\d+$";
        return str.matches(regEx);
    }
}

性能分析
这里写图片描述

程序运行结果如上图，可以看出初始化词典的时间占据大部分时间，而且在我使用前缀树Trie后构造词典时时间更加大。在前面的实验中，根据在词典中查找词语时的性能优化，从普通的ArrayList的查找一直到Trie索引树的二分查找，性能不断提升，我们可以知道分词程序的性能提升空间主要是在查找词典的算法中。

YABAJ
关注
专栏目录
中文分词词库整理.7z
06-30
中文分词是自然语言处理（NLP）领域中的基础任务，它是将连续的汉字序列切分成具有语义意义的词语序列。在这个“中文分词词库整理.7z”压缩包中，包含的可能是一个精心整理的中文词汇集合，用于支持各种中文分词算法...
中文分词处理
jackbon8的博客
04-16 1342
python处理中文分词 https://github.com/tsroten/pynlpir （一个外国小哥搞得，还有文档介绍http://pynlpir.rtfd.org）
【5】使用结巴分词对分类语料库分词
搬砖小工053
08-01 4981
转自 NLP论坛 http://www.threedweb.cn/thread-1295-1-1.html 工作空间（workspace）路径：X:\WorkSpace\text_mining X为Windows硬盘盘符 项目主目录：text_mining |-- text_corpus_small 目录：未分词训练语料库路径，子目录名称为语料库的分类，该类所属文本就位于子目录中
java中文分词工具_对Pandas百万级文本进行中文分词加速，看这一篇就足够了
weixin_39637386的博客
12-03 772
一、摘要很多NLP相关的任务都需要分词，而当文本语料比较多时，用python处理分词任务的过程会比较消耗时间。本文测试了对pandas百万级中文语料分词的多种实现方案和相应的执行时间，希望读者可以根据本次实验的结果选择适合自己的实现方式，节约分词任务带来的时间损耗。尤其是在没有集群环境下，需要在单机上处理大量文本分词任务时，可以有所参考。我们测试的多种方案中，最好的方案比最差的方案速度提升了318...
字符串中判断只有英文字母，判断是否有忽略大小写相同的字符串
lihonghao1017的专栏
02-02 1765
判断只有英文字母 public static boolean isEnglish(String charaString) { return charaString.matches("^[a-zA-Z]*"); } 判断只有英文字母的字符串中，有忽略大小写的相同的字符串 String key="list123TeXthaoge"; String tag="text"; Pattern
判断接收的字符串是英文还是中文
小猪奋斗
11-27 2550
这只是其中一种方法，通过比较存储的空间大小判断public class ChineseOrEnglishUtil{ public static String isChineseOrEnglish(String charaString){ boolean result =false; //英文 result=charaString.matches("^[a-zA-
中文分词词库大全词库
08-21
### 中文分词词库大全词库解析 #### 标题与描述概述 标题：“中文分词词库大全词库” 描述重复强调了一个词典的来源及其格式（TXT）。这表明该词库是为了中文自然语言处理（NLP）任务中的分词而准备的资源。中文...
asp 的中文分词
10-30
中文分词是指将连续的汉字序列切分成具有独立语义的词语，这是中文自然语言处理的基础。 在给出的代码中，我们可以看到一个简单的ASP脚本实现中文分词的过程。首先，代码定义了两个字符串变量`a`和`b`。`a`包含了一...
中文分词学习版
10-11
CSW中文分词组件，是一套可自动将一段文本按常规汉语词组进行拆分，并以指定方式进行分隔的COM组件。本组件采用独有的高效的分词引擎及拆分算法，具有准确、高速、资源占用率小等特点。为了满足客户对文本语义进行...
中文分词词库整理 rar
10-08
30万 中文分词词库.txt 42537条伪原创词库.txt 百度分词词库.txt 词库地址.txt 词库下载地址.txt
Elasticsearch7.7.1集群不能相互发现的问题解决以及Elasticsearch7.7.1安装analysis-ik中文分词插件的应用
本博客记录了从2014年以来在工作学习中遇到的技术问题、解决方法以及部分个人人生经历、经验等内容。
09-25 778
在使用elasticsearch7.7.1搭建集群，使用了3台服务器作为节点，但在搭建的过程中发现每台服务器的elasticsearch服务都正常，但是不能相互发现，期间进行了一些配置的修改偶尔出现了相互发现，但没过多久又断了联系。主要原因还是elasticsearch7.*版本有些不一样，网上的资料各个版本都有，但都比较老，好多配置项在7版本中已经废弃了，而到网上一找到处都充斥着这些老版本的使用教程，新的太少。ik_smart: 会做最粗粒度的拆分，比如我们去电影院吧，里面的电影院就直接是电影院。
向前维泰比算法Matlab代码.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
#-ssm-033-mysql-校园二手交易系统-.zip
最新发布
10-09
现如今,校园二手交易系统是商业贸易中的一条非常重要的道路，可以把其从传统的实体模式中解放中来，网上购物可以为消费者提供巨大的便利。通过校园二手交易系统这个平台，可以使用户足不出户就可以了解现今的流行趋势和丰富的商品信息，为用户提供了极大的方便，校园二手交易系统的主要功能包含：商品类别管理、商品的信息管理、订单管理、用户的管理等。网站分为管理员、会员用户这二种用户平台。校园二手交易系统主要使用目前JSP中最流行的SSM框架和Eclipse编辑器、MYSQL数据库设计并实现的。实现了一个校园二手交易系统网站。能够让广大消费者体验到网上平台订餐的乐趣，为网上购物提供了一个管理高效的、决策科学化、安全有效的电子商务平台。 关键词：校园二手交易系统，SSM，Eclipse，商业贸易
MATLAB软件的汽车框定系统【GUI界面版本】.zip
10-09
数据库课程设计
用于开发和测试大脑情感唤醒特征（BAAS）的代码.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
等效氢气消耗最小的燃料电池混合动力能量管理策略 基于matlab平台开展，纯编程，.m文件 该方法作为在线能量管理方法，可作为比
10-09
等效氢气消耗最小的燃料电池混合动力能量管理策略 基于matlab平台开展，纯编程，.m文件 该方法作为在线能量管理方法，可作为比较其他能量管理方法的对比对象。 该方法为本人硕士期间编写，可直接运行 可更任意工况运行
基于MatlabGUI界面版的数字图像处理[MatlabGUI界面版].zip
10-09
数据库课程设计
基于Python实现的今天吃什么程序.zip
10-09
基于Python实现的今天吃什么程序.zip
群智能算法优化bp：将思维进化算法结合两层bp，对数据进行预测回归，对多层bp神经网络有兴趣的朋友可以借鉴，有意咨询，非诚勿扰
10-09
群智能算法优化bp：将思维进化算法结合两层bp，对数据进行预测回归，对多层bp神经网络有兴趣的朋友可以借鉴，有意咨询，非诚勿扰。 思维进化优化算法（Memetic Evolutionary Algorithm）结合两层BP神经网络的组合具有一些优点。 以下是其中几个方面的优势： 组合技术优势：Memetic Evolutionary Algorithm（MEA）与两层BP神经网络的结合，可以将遗传算法与神经网络相结合，充分发挥各自的优势。 MEA在优化问题中能够进行全局搜索和适应度评估，而BP神经网络则可以进行局部优化和拟合模型。 高效的全局搜索能力：MEA通过种群的进化和交叉操作，能够在搜索空间中进行全局搜索，找到可能是最优解的候选解。 这种能力使得MEA能够快速找到问题的潜在解决方案，并加速算法的收敛速度。 优化参数拟合能力：两层BP神经网络具有强大的拟合能力，可以通过学习样本数据来寻找最佳参数配置。 通过将MEA与神经网络相结合，可以利用MEA的全局搜索能力来选择初始的参数配置，然后利用BP神经网络对参数进行进一步优化，得到更精确的结果。 可解释性和可调节性：BP神经网络的隐藏层
中文分词技术浅析
浅谈中文分词 中文分词是信息处理领域中一个非常重要的基础步骤，对于中文信息处理的基础性工作具有重要作用。下面将详细介绍中文分词的概念、缘起、必要性和应用领域。 一、中文分词的概念 中文分词是指将连续的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值