由隐马尔科夫意淫无字典中文分词 C#

最新推荐文章于 2021-05-23 03:54:28 发布
最新推荐文章于 2021-05-23 03:54:28 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： 大数据、神经网络、深度学习、机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/joycesunny/article/details/44856007
版权 
using System;
using System;
using System.Windows.Forms;
using System.IO;
using System.Text.RegularExpressions;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;

namespace HMM
{
    public partial class Form1 : Form
    {
        string[] arrayData;
        DirectoryInfo di;
        FileInfo[] fis;
        Hashtable htDict = new Hashtable();
        double singleCutRate;

        public Form1()
        {
            InitializeComponent();
            label1.Text = "先预处理！";
            progressBar1.Visible = false;
            di = new DirectoryInfo("data");
            fis = di.GetFiles("*.txt");
            arrayData = new string[fis.Length];
        }

        private void Form1_Resize(object sender, EventArgs e)
        {
            this.Width = 800;
            this.Height = 600;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            if (!new FileInfo("dict.txt").Exists)
            {
                int count = 0;
                progressBar1.Visible = true;
                BackgroundWorker worker = new BackgroundWorker();
                worker.WorkerReportsProgress = true;  //报告进度  
                worker.DoWork += (s, o) =>
                {
                    int progressCount = 1;
                    foreach (FileInfo i in fis)
                    {
                        StreamReader sr = new StreamReader(i.FullName, System.Text.Encoding.Default);
                        arrayData[progressCount - 1] = sr.ReadToEnd();
                        sr.Close();
                        worker.ReportProgress((int)((double)progressCount / (double)fis.Length * 33), null);
                        progressCount++;
                    }
                    for (int i = 0; i < arrayData.Length; i++)
                    {
                        arrayData[i] = Regex.Replace(arrayData[i], @"[^\u4e00-\u9fa5]", "");
                        for (int j = 0; j < arrayData[i].Length; j++)
                        {
                            string strWord = arrayData[i].Substring(j, 1);
                            if (IsChinese(strWord))
                            {
                                if (htDict.ContainsKey(strWord))
                                {
                                    htDict[strWord] = ((int)htDict[strWord]) + 1;
                                }
                                else
                                {
                                    htDict.Add(strWord, 1);
                                }
                            }
                        }
                        worker.ReportProgress((int)((double)i / (double)arrayData.Length * 33) + 33, null);
                    }
                    StreamWriter sw = new StreamWriter("dict.txt", false, System.Text.Encoding.Default);
                    foreach (DictionaryEntry i in htDict)
                    {
                        sw.WriteLine(i.Key + "|" + i.Value);
                        count++;
                        sw.Flush();
                        worker.ReportProgress((int)((double)count / (double)htDict.Count * 33) + 67, null);
                    }
                    sw.Close();
                };
                worker.RunWorkerCompleted += (s, o) =>
                {
                    this.Invoke(new MethodInvoker(() => { progressBar1.Visible = false; progressBar1.Value = 0; label1.Text = "预处理完成！|" + count; }));
                };
                worker.ProgressChanged += (s, o) =>
                {
                    progressBar1.Style = ProgressBarStyle.Continuous;
                    progressBar1.Value = o.ProgressPercentage;
                };
                worker.RunWorkerAsync();
            }
            else
            {
                int count = 0;
                progressBar1.Visible = true;
                BackgroundWorker worker = new BackgroundWorker();
                worker.WorkerReportsProgress = true;  //报告进度  
                worker.DoWork += (s, o) =>
                {
                    int progressCount = 1;
                    foreach (FileInfo i in fis)
                    {
                        StreamReader sr = new StreamReader(i.FullName, System.Text.Encoding.Default);
                        arrayData[progressCount - 1] = sr.ReadToEnd();
                        sr.Close();
                        worker.ReportProgress((int)((double)progressCount / (double)fis.Length * 33), null);
                        progressCount++;
                    }
                    for (int i = 0; i < arrayData.Length; i++)
                    {
                        arrayData[i] = Regex.Replace(arrayData[i], @"[^\u4e00-\u9fa5]", "");
                        worker.ReportProgress((int)((double)i / (double)arrayData.Length * 33) + 33, null);
                    }
                    StreamReader reader = new StreamReader("dict.txt", System.Text.Encoding.Default);
                    string line = "";
                    while ((line = reader.ReadLine()) != null)
                    {
                        htDict[line.Substring(0, 1)] = line.Substring(2);
                        count++;
                    }
                    reader.Close();
                    worker.ReportProgress(100, null);
                };
                worker.RunWorkerCompleted += (s, o) =>
                {
                    this.Invoke(new MethodInvoker(() => { progressBar1.Visible = false; progressBar1.Value = 0; label1.Text = "预处理完成！|" + count; }));
                };
                worker.ProgressChanged += (s, o) =>
                {
                    progressBar1.Style = ProgressBarStyle.Continuous;
                    progressBar1.Value = o.ProgressPercentage;
                };
                worker.RunWorkerAsync();
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            if (label1.Text != "先预处理！" && textBox1.Text.Trim() != "")
            {
                textBox2.Text = "";
                if (!double.TryParse(textBox3.Text.Trim(), out singleCutRate))
                {
                    singleCutRate = 0.01;
                }
                List<string> list = new List<string>();
                string strSplitWords = Regex.Replace(textBox1.Text.Trim(), @"[^\u4e00-\u9fa5]", "");
                int startPos = 0;
                int m = 1;
                string strWord1 = "";
                string strWord2 = "";
                progressBar1.Visible = true;
                BackgroundWorker worker = new BackgroundWorker();
                worker.WorkerReportsProgress = true;  //报告进度
                worker.DoWork += (s, o) =>
                {
                    while (strSplitWords.Length >= 2)
                    {
                        if (strWord1 == "")
                        {
                            strWord1 = strSplitWords.Substring(startPos, m);
                        }
                        strWord2 = strSplitWords.Substring(startPos, ++m);
                        double x1 = (double)ReturnCount(strWord1, arrayData);
                        double y1 = (double)ReturnTotalCount(strWord1);
                        if (y1 == 0)
                            y1++;
                        double a = x1 / y1;
                        double x2 = (double)ReturnCount(strWord2, arrayData);
                        double y2 = (double)ReturnTotalCount(strWord2);
                        if (y2 == 0)
                            y2++;
                        double b = x2 / y2;
                        if ((a < 1 && a > b) || (a == 1 && b < singleCutRate) || (a == 0 && b == 0))
                        {
                            list.Add(strWord1);
                            startPos += strWord1.Length;
                            worker.ReportProgress((int)((double)startPos / (double)strSplitWords.Length * 100), null);
                            m = 1;
                            strWord1 = "";
                            strWord2 = "";
                            if ((strSplitWords.Length - startPos) == 1)
                            {
                                list.Add(strSplitWords.Substring(startPos, 1));
                                break;
                            }
                            else if ((strSplitWords.Length - startPos) < 1)
                            {
                                break;
                            }
                        }
                        else
                        {
                            strWord1 = strWord2;
                            strWord2 = "";
                            if ((strSplitWords.Length - startPos - m) < 1)
                            {
                                list.Add(strWord1);
                                startPos += strWord1.Length;
                                worker.ReportProgress((int)((double)startPos / (double)strSplitWords.Length * 100), null);
                                break;
                            }
                        }
                    }
                    worker.ReportProgress(100, null);
                };
                worker.RunWorkerCompleted += (s, o) =>
         {
             this.Invoke(new MethodInvoker(() =>
             {
                 progressBar1.Visible = false;
                 progressBar1.Value = 0;
                 foreach (string i in list)
                 {
                     textBox2.Text += i + "|";
                 }
                 label2.Text = "分词完成！";
             }));
         };
                worker.ProgressChanged += (s, o) =>
                {
                    progressBar1.Style = ProgressBarStyle.Continuous;
                    progressBar1.Value = o.ProgressPercentage;
                };
                worker.RunWorkerAsync();
            }
        }

        public bool IsChinese(string str)
        {
            return Regex.IsMatch(str, @"^[\u4e00-\u9fa5]+$");
        }

          public int ReturnCount(string s, string[] d)
        {
            int count = 0;
            for (int i = 0; i < d.Length; i++)
            {
                count += Regex.Matches(d[i], s).Count;
            }
            return count;
        }

        public int ReturnTotalCount(string s)
        {
            int total = 0;
            for (int i = 0; i < s.Length; i++)
            {
                if (htDict.ContainsKey(s.Substring(i, 1)))
                {
                    total += Convert.ToInt32(htDict[s.Substring(i, 1)]);
                }
            }
            return total;
        }
    }
}




最近在看机器学习方面的书，看到隐马尔科夫，意淫了一下无字典中文分词的可能性，我设想了一种分词方式，并无聊了一个程序，因为执行效率相当差，所以添加了进度条，否则真的等到受不了，仅供参考

1、下载了3200本各类电子书，600多M

2、预先扫描每个字出现的概率P（w）

3、清除待分词内容c中非中文字符

4、从左向右扫描ci，(i为字数,每一位为w1、w2、w3.....wi),

       开始时：计算第一个字c1的a=P(c1)/P(w1)和前两个字c2的b=P(c2)/(P(w1)+P(w2))

   comp:if ((a < 1 && a > b) || (a == 1 && b < singleCutRate) || (a == 0 && b == 0))

   则分割c1,指针向后移动i

   否则继续比较 前两个字 a=P(c2)/(P(w1)+P(w2)) 

                   和前三个字  b=P(c3)/(P(w1)+P(w2)+P(w3)) 的大小  循环到comp

    注意检测c的尾部并及时跳出循环，singleCutRate用于估算单字的切割概率，比如

   “中” 和 “中国” ，当 P(中国)/(P(中)+P(国)) >=0.05 认为“中国”是固有词汇，否则直接分割“中”，这个切割概率需要调教一个合理的数值，似乎最好的区间在0.005上下。

    yy完毕!

       


@CAPRICA@
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
infer-hmm:使用 Infer.NET 的隐藏马尔可夫模型的 C# 模型定义。 此代码可以轻松地对隐马尔可夫模型的模型参数和状态进行近似贝叶斯推理
07-05
infer-hmm：隐马尔可夫模型的 Infer.NET 实现 (HMM) 是一种用于对顺序过程建模的统计工具。 该模型由离散的未观察变量的马尔可夫链组成，每个变量发出一个观察到的连续变量。 链中每个变量之间的概率依赖性由一组模型参数控制。 下面是一个 HMM 的图形模型： 该项目使用为 HMM 提供 C# 定义。 此代码使对 HMM 的模型参数和状态运行近似贝叶斯推理变得容易。 特别感谢 Microsoft Research 添加对链模型的支持，以及在提高模型效率方面的专业知识。 要求 .NET 框架 4.5 推断.NET 2.6
无词典分词
weixin_34167043的博客
05-19 149
看了互联网时代的社会语言学：基于SNS的文本数据挖掘 blog地址：http://www.matrix67.com/blog/archives/5044 全文思路 1、介绍了无词典分词，且要考虑两个因素，一是内部凝固程度，二是外部自由程度 2、举例说明，使用后缀数组，以O（nlogn）的时间复杂度来实现该算法 3、介绍应用场景 白话文 １、不需要词典就把这句话给分了，有两个重点考核，...
隐马尔科夫模型c#语言算法实现,HMM学习最佳范例四：隐马尔科夫模型
weixin_39540020的博客
05-23 184
四、隐马尔科夫模型(Hidden Markov Models)1、定义(Definition of a hidden Markov model)一个隐马尔科夫模型是一个三元组(pi, A, B)。：初始化概率向量；：状态转移矩阵；：混淆矩阵；在状态转移矩阵及混淆矩阵中的每一个概率都是时间无关的——也就是说，当系统演化时这些矩阵并不随时间改变。实际上，这是马尔科夫模型关于真实世界最不现实的一个假设。...
隐马尔科夫模型c#语言算法实现,HMM隐马尔科夫模型（三）C#调用示例 | 春小麦...
weixin_39820136的博客
05-23 206
同系列文章：TestHMMCS.csusing System;using Splash;namespace SplashCheck{class TestHMMCS{enum Weather { Sunny, Cloudy, Rainy }; // 隐藏状态(天气)enum Seaweed { Dry, Dryish, Damp, Soggy }; // 观察状态(海藻湿度)static voi...
隐马尔科夫模型C#类库调用示例
秦建辉的专栏
06-09 2461
测试代码using System;using Splash;namespace SplashCheck{ class TestHMMCS { enum Weather { Sunny, Cloudy, Rainy }; // 隐藏状态（天气） enum Seaweed { Dry, Dryish, Damp, Soggy
HMM隐马尔科夫模型进行中文文本分词.zip
10-02
隐马尔科夫模型（Hidden Markov Model，简称HMM）是统计建模中的一种重要方法，常用于处理序列数据，如语音识别、自然语言处理等领域。在中文文本分词中，HMM起到了关键作用，它能有效地识别并分割出中文句子中的...
基于隐马尔科夫模型的中文分词研究_魏晓宁1
08-04
【总结】基于隐马尔科夫模型的中文分词研究针对汉语的特性，利用统计模型和马尔科夫假设，提高分词效率和准确性。随着技术的发展，HMM结合其他技术如深度学习，将进一步推动中文分词技术的进步。
隐马尔科夫分词源代码
06-02
隐马尔科夫模型（Hidden Markov Model，简称HMM）是统计建模方法中的一种，常用于自然语言处理中的序列标注任务，如中文分词。在这个任务中，HMM被用来识别和分割中文文本中的词语，以实现对文本的准确理解和分析。...
隐马尔科夫算法：中文分词神器
06-19
由此引出了隐马尔科夫分词算法，并以分词实际应用为例，介绍了隐马尔科夫分词算法的整个逻辑包括参数矩阵如何训练。同时演示并提供了隐马尔科夫分词的源码。在课程最后介绍了两种其他类型的分词算法并类比于隐...
基于隐马尔科夫的中文分词
05-09
基于隐马尔科夫的中文分词
C#中文分词不完全版
04-14
C#中文分词不完全版，因为技术原因放不了完全版，见谅
统计分词/无字典分词学习(1):介绍和语料准备-附件资源
03-05
统计分词/无字典分词学习(1):介绍和语料准备-附件资源
C#写的马尔可夫-预测算法实例，简单明了。
07-14
马尔可夫的教程说的很多，但是基本都没有代码实例，这个预测算法的文章，基本只有大学的论文才能找到比较详细的资料，但是都没有代码实例，特别是边际概率,离散型变量,检验'马氏性',自相关系数,滞时权重等说的不尽清楚，算法到代码，往往是错误的。找了大量的论文，才把这个代码写出来，并且通过验效。
C#源码-马尔可夫算法.rar
08-17
C#版本的马尔可夫算法，代码能正常运行，下载即可研究。该代码并非本人原创，是整理学习资料时偶然发现以前研究过的算法共享出来给大家
HmmDotNet:NET的隐马尔可夫模型。
05-21
HmmDotNet 该库在C＃（。NET）中实现了隐马尔可夫模型。 在统计模块中，我实现了以下分布： 离散分布 单变量高斯分布 多元高斯分布 具有多元高斯成分的混合物分布 也可以通过实现一些基本的接口分发库来扩展。 目前在机器学习库中，我已经实现了以下模型： 高斯混合模型（GMM） 隐马尔可夫模型（HMM）1.离散排放2.高斯排放正变量3.高斯多元排放4.高斯混合排放 有关更多信息，请参见项目Wiki
统计分词/无字典分词学习(1):介绍和语料准备
wangliang_f的专栏
12-24 1806
分词算法中，一般都需要一个词典，但这些词典往往很难覆盖所有的词，特别是在一些专业领域，甚至有超过40%的词都不在词典里面，这样首先就需要“学习”大量的新词，否则分词准确性很难提高，进一步的，有研究就干脆不要词典了，由算法自动从大量的语料中学得一个词典，这就是统计分词，或者成为无字典分词。一般就只预设一个小规模的词典，后者没有词典，首先从大量的未标注语料，也就是生语料中学习出一个词典，然后利用这个词
中文分词之隐马尔可夫模型
qq_28286027的博客
03-01 2363
隐马尔可夫模型理论知识： 角色：收拾烂摊子的角色 1) 生成方式 2) 路径选择（viterbi算法）——&gt;动态规划 上篇文章讲到语言模型（1,2,3） 二元语言模型 == 一阶马尔科夫模型 马尔科夫模型有3类重要参数： 1、状态 2、初始概率 初始概率计算方法举例： 假设有100篇文章， 时光荏苒 30篇 -&gt; 30 / 100 今天 10篇 ...
统计分词/无字典分词学习(7): 模型方法
wangliang_f的专栏
01-03 1583
前面几篇讨论的统计分词基本都是基于这样一个理念，首先，把所有的ngram片段都当成候选词，这些ngram的概率可以用极大似然估计获得；然后，选择一系列指标来过滤这些ngram片段，主要的指标包括词频、互信息、边界熵三个指标，对每个指标，又可以有不同的变形，此外还有形式熵等其他的一些类似指标。 但这种做法，存在一个主要问题是，如何选取不同指标的阈值，来构造最终的词典，实践中，往往就是反复的做实验，
统计分词/无字典分词学习(5):候选片段的过滤方法，边界稳定性
wangliang_f的专栏
12-26 1119
互信息主要是过滤掉那些内部结合不紧密的片段，但只过滤掉了3%的无意义片段，而我们会发现，大量的不是词的片段是这样的形式： informa、informat、informati，informatio这样的，属于information这个高频词一部分的片段。这些片段因为是某个词的一部分，因此，有这样一个明显的特点，就是其后续的一个字母或者几个字母非常固定。 如informa，后续的一个字母只有l和
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值