Go语言的分词器(sego)
今天,主要来介绍一个Go语言的中文分词器,即sego。本分词器是由陈辉写的,他的微博在这里,github详
见此处。由于之前他在Google,所以对Go语言特别熟悉。sego的介绍如下
sego是Go语言的中文分词器,词典用前缀树实现, 分词器算法为基于词频的最短路径加动态规划。
支持普通和搜索引擎两种分词模式,支持用户词典、词性标注,可运行JSON RPC服务。
分词速度单线程2.7MB/s,goroutines并发13MB/s, 处理器Core i7-3615QM 2.30GHz 8核。
接下来,以如下几个方面来介绍sego
1. sego的安装
2. sego的原理
3. sego的使用
1. sego的安装
首先,在Go语言中,有很多第三方包,可以帮助我们实现某些特定的功能。比如这里。而sego的项目在这里。
先把工程根目录加入GOPATH,然后执行如下命令
然后在sego项目根目录下就得到了src和pkg,这是一个Go语言项目,可以在src中创建文件进行使用。
sego的源文件如下
其中词库在data目录下,至此,sego就可以直接使用了。接下来会介绍sego的原理。
2. sego的原理
之前,我用过中科院的分词器ICTCLAS2014,它是一个非常优秀的分词器,支持C++,Java,C#,Hadoop等
等,使用起来非常方便,分词效果也不错,但是它不是开源的。今天介绍的sego分词器是开源Go语言分词器,
它的原理是:词典用前缀树实现,而分词器算法为基于词频的最短路径加动态规划。具体参考这两部分的代码
词典:dictionary.go
package sego import ( "bytes" ) // Dictionary结构体实现了一个字串前缀树,一个分词可能出现在叶子节点也有可能出现在非叶节点 type Dictionary struct { root node // 根节点 maxTokenLength int // 词典中最长的分词 numTokens int // 词典中分词数目 tokens []*Token // 词典中所有的分词,方便遍历 totalFrequency int64 // 词典中所有分词的频率之和 } // 前缀树节点 type node struct { word Text // 该节点对应的字元 token *Token // 当此节点没有对应的分词时值为nil children []*node // 该字元后继的所有可能字元,当为叶子节点时为空 } // 词典中最长的分词 func (dict *Dictionary) MaxTokenLength() int { return dict.maxTokenLength } // 词典中分词数目 func (dict *Dictionary) NumTokens() int { return dict.numTokens } // 词典中所有分词的频率之和 func (dict *Dictionary) TotalFrequency() int64 { return dict.totalFrequency } // 向词典中加入一个分词 func (dict *Dictionary) addToken(token *Token) { current := &dict.root for _, word := range token.text { // 一边向深处移动一边添加节点(如果需要的话) current = upsert(¤t.children, word) } // 当这个分词不存在词典中时添加此分词,否则忽略 if current.token == nil { current.token = token if len(token.text) > dict.maxTokenLength { dict.maxTokenLength = len(token.text) } dict.numTokens++ dict.tokens = append(dict.tokens, token) dict.totalFrequency += int64(token.frequency) } } // 在词典中查找和字元组words可以前缀匹配的所有分词 // 返回值为找到的分词数 func (dict *Dictionary) lookupTokens(words []Text, tokens []*Token) int { // 特殊情况 if len(words) == 0 { return 0 } current := &dict.root numTokens := 0 for _, word := range words { // 如果已经抵达叶子节点则不再继续寻找 if len(current.children) == 0 { break } // 否则在该节点子节点中进行下个字元的匹配 index, found := binarySearch(current.children, word) if !found { break } // 匹配成功,则跳入匹配的子节点中 current = current.children[index] if current.token != nil { tokens[numTokens] = current.token numTokens++ } } return numTokens } // 二分法查找字元在子节点中的位置 // 如果查找成功,第一个返回参数为找到的位置,第二个返回参数为true // 如果查找失败,第一个返回参数为应当插入的位置,第二个返回参数false func binarySearch(nodes []*node, word Text) (int, bool) { start := 0 end := len(nodes) - 1 // 特例: if len(nodes) == 0 { // 当slice为空时,插入第一位置 return 0, false } compareWithFirstWord := bytes.Compare(word, nodes[0].word) if compareWithFirstWord < 0 { // 当要查找的元素小于首元素时,插入第一位置 return 0, false } else if compareWithFirstWord == 0 { // 当首元素等于node时 return 0, true } compareWithLastWord := bytes.Compare(word, nodes[end].word) if compareWithLastWord == 0 { // 当尾元素等于node时 return end, true } else if compareWithLastWord > 0 { // 当尾元素小于node时 return end + 1, false } // 二分 current := end / 2 for end-start > 1 { compareWithCurrentWord := bytes.Compare(word, nodes[current].word) if compareWithCurrentWord == 0 { return current, true } else if compareWithCurrentWord < 0 { end = current current = (start + current) / 2 } else { start = current current = (current + end) / 2 } } return end, false } // 将字元加入节点数组中,并返回插入的节点指针 // 如果字元已经存在则返回存在的节点指针 func upsert(nodes *[]*node, word Text) *node { index, found := binarySearch(*nodes, word) if found { return (*nodes)[index] } *nodes = append(*nodes, nil) copy((*nodes)[index+1:], (*nodes)[index:]) (*nodes)[index] = &node{word: word} return (*nodes)[index] }
分词器算法:segmenter.go
//Go中文分词 package sego import ( "bufio" "fmt" "log" "math" "os" "strconv" "strings" "unicode" "unicode/utf8" ) const ( minTokenFrequency = 2 // 仅从字典文件中读取大于等于此频率的分词 ) // 分词器结构体 type Segmenter struct { dict *Dictionary } // 该结构体用于记录Viterbi算法中某字元处的向前分词跳转信息 type jumper struct { minDistance float32 token *Token } // 返回分词器使用的词典 func (seg *Segmenter) Dictionary() *Dictionary { return seg.dict } // 从文件中载入词典 // // 可以载入多个词典文件,文件名用","分隔,排在前面的词典优先载入分词,比如 // "用户词典.txt,通用词典.txt" // 当一个分词既出现在用户词典也出现在通用词典中,则优先使用用户词典。 // // 词典的格式为(每个分词一行): // 分词文本 频率 词性 func (seg *Segmenter) LoadDictionary(files string) { seg.dict = new(Dictionary) for _, file := range strings.Split(files, ",") { log.Printf("载入sego词典 %s", file) dictFile, err := os.Open(file) defer dictFile.Close() if err != nil { log.Fatalf("无法载入字典文件 \"%s\" \n", file) } reader := bufio.NewReader(dictFile) var text string var freqText string var frequency int var pos string // 逐行读入分词 for { size, _ := fmt.Fscanln(reader, &text, &freqText, &pos) if size == 0 { // 文件结束 break } else if size < 2 { // 无效行 continue } else if size == 2 { // 没有词性标注时设为空字符串 pos = "" } // 解析词频 var err error frequency, err = strconv.Atoi(freqText) if err != nil { continue } // 过滤频率太小的词 if frequency < minTokenFrequency { continue } // 将分词添加到字典中 words := splitTextToWords([]byte(text)) token := Token{text: words, frequency: frequency, pos: pos} seg.dict.addToken(&token) } } // 计算每个分词的路径值,路径值含义见Token结构体的注释 logTotalFrequency := float32(math.Log2(float64(seg.dict.totalFrequency))) for _, token := range seg.dict.tokens { token.distance = logTotalFrequency - float32(math.Log2(float64(token.frequency))) } // 对每个分词进行细致划分,用于搜索引擎模式,该模式用法见Token结构体的注释。 for _, token := range seg.dict.tokens { segments := seg.segmentWords(token.text, true) // 计算需要添加的子分词数目 numTokensToAdd := 0 for iToken := 0; iToken < len(segments); iToken++ { if len(segments[iToken].token.text) > 1 { // 略去字元长度为一的分词 // TODO: 这值得进一步推敲,特别是当字典中有英文复合词的时候 numTokensToAdd++ } } token.segments = make([]*Segment, numTokensToAdd) // 添加子分词 iSegmentsToAdd := 0 for iToken := 0; iToken < len(segments); iToken++ { if len(segments[iToken].token.text) > 1 { token.segments[iSegmentsToAdd] = &segments[iSegmentsToAdd] iSegmentsToAdd++ } } } log.Println("sego词典载入完毕") } // 对文本分词 // // 输入参数: // bytes UTF8文本的字节数组 // // 输出: // []Segment 划分的分词 func (seg *Segmenter) Segment(bytes []byte) []Segment { return seg.internalSegment(bytes, false) } func (seg *Segmenter) internalSegment(bytes []byte, searchMode bool) []Segment { // 处理特殊情况 if len(bytes) == 0 { return []Segment{} } // 划分字元 text := splitTextToWords(bytes) return seg.segmentWords(text, searchMode) } func (seg *Segmenter) segmentWords(text []Text, searchMode bool) []Segment { // 搜索模式下该分词已无继续划分可能的情况 if searchMode && len(text) == 1 { return []Segment{} } // jumpers定义了每个字元处的向前跳转信息,包括这个跳转对应的分词, // 以及从文本段开始到该字元的最短路径值 jumpers := make([]jumper, len(text)) tokens := make([]*Token, seg.dict.maxTokenLength) for current := 0; current < len(text); current++ { // 找到前一个字元处的最短路径,以便计算后续路径值 var baseDistance float32 if current == 0 { // 当本字元在文本首部时,基础距离应该是零 baseDistance = 0 } else { baseDistance = jumpers[current-1].minDistance } // 寻找所有以当前字元开头的分词 numTokens := seg.dict.lookupTokens( text[current:minInt(current+seg.dict.maxTokenLength, len(text))], tokens) // 对所有可能的分词,更新分词结束字元处的跳转信息 for iToken := 0; iToken < numTokens; iToken++ { location := current + len(tokens[iToken].text) - 1 if !searchMode || current != 0 || location != len(text)-1 { updateJumper(&jumpers[location], baseDistance, tokens[iToken]) } } // 当前字元没有对应分词时补加一个伪分词 if numTokens == 0 || len(tokens[0].text) > 1 { updateJumper(&jumpers[current], baseDistance, &Token{text: []Text{text[current]}, frequency: 1, distance: 32, pos: "x"}) } } // 从后向前扫描第一遍得到需要添加的分词数目 numSeg := 0 for index := len(text) - 1; index >= 0; { location := index - len(jumpers[index].token.text) + 1 numSeg++ index = location - 1 } // 从后向前扫描第二遍添加分词到最终结果 outputSegments := make([]Segment, numSeg) for index := len(text) - 1; index >= 0; { location := index - len(jumpers[index].token.text) + 1 numSeg-- outputSegments[numSeg].token = jumpers[index].token index = location - 1 } // 计算各个分词的字节位置 bytePosition := 0 for iSeg := 0; iSeg < len(outputSegments); iSeg++ { outputSegments[iSeg].start = bytePosition bytePosition += textSliceByteLength(outputSegments[iSeg].token.text) outputSegments[iSeg].end = bytePosition } return outputSegments } // 更新跳转信息: // 1. 当该位置从未被访问过时(jumper.minDistance为零的情况),或者 // 2. 当该位置的当前最短路径大于新的最短路径时 // 将当前位置的最短路径值更新为baseDistance加上新分词的概率 func updateJumper(jumper *jumper, baseDistance float32, token *Token) { newDistance := baseDistance + token.distance if jumper.minDistance == 0 || jumper.minDistance > newDistance { jumper.minDistance = newDistance jumper.token = token } } // 取两整数较小值 func minInt(a, b int) int { if a > b { return b } return a } // 取两整数较大值 func maxInt(a, b int) int { if a > b { return a } return b } // 将文本划分成字元 func splitTextToWords(text Text) []Text { output := make([]Text, len(text)) current := 0 currentWord := 0 inAlphanumeric := true alphanumericStart := 0 for current < len(text) { r, size := utf8.DecodeRune(text[current:]) if size <= 2 && (unicode.IsLetter(r) || unicode.IsNumber(r)) { // 当前是拉丁字母或数字(非中日韩文字) if !inAlphanumeric { alphanumericStart = current inAlphanumeric = true } } else { if inAlphanumeric { inAlphanumeric = false if current != 0 { output[currentWord] = toLower(text[alphanumericStart:current]) currentWord++ } } output[currentWord] = text[current : current+size] currentWord++ } current += size } // 处理最后一个字元是英文的情况 if inAlphanumeric { if current != 0 { output[currentWord] = toLower(text[alphanumericStart:current]) currentWord++ } } return output[:currentWord] } // 将英文词转化为小写 func toLower(text []byte) []byte { output := make([]byte, len(text)) for i, t := range text { if t >= 'A' && t <= 'Z' { output[i] = t - 'A' + 'a' } else { output[i] = t } } return output }
3. sego的使用
接下来介绍sego的使用。首先介绍网页版的分词器,在源文件的server目录下面,运行server.go,如下
server.go是一个轻量级的web服务器,端口为8080,在浏览器打开后如下图
接下来,对如下文章进行分词
近年结识了一位警察朋友,好枪法。不单单在射击场上百发百中,更在解救人质的现场,次次百步穿杨。当然了,这个“杨”不是杨树的杨,而是匪徒的代称。 我向他请教射击的要领。他说,很简单,就是极端的平静。我说这个要领所有打枪的人都知道,可是做不到。他说,记住,你要像烟灰一样松散。只有放松,全部潜在的能量才会释放出来,协同你达到完美。 他的话我似懂非懂,但从此我开始注意以前忽略了的烟灰。烟灰,尤其是那些优质香烟燃烧后的烟灰,非常松散,几乎没有重量和形状,真一个大象无形。它们懒洋洋地趴在那里,好像在冬眠。其实,在烟灰的内部,栖息着高度警觉和机敏的鸟群,任何一阵微风掠过,哪怕只是极轻微的叹息,它们都会不失时机地腾空而起驭风而行。它们的力量来自放松,来自一种飘扬的本能。 松散的反面是紧张。几乎每个人都有过由于紧张而惨败的经历。比如,考试的时候,全身肌肉僵直,心跳得好像无数个小炸弹在身体的深浅部位依次爆破。手指发抖头冒虚汗,原本记得滚瓜烂熟的知识,改头换面潜藏起来,原本泾渭分明的答案变得似是而非,泥鳅一样滑走……面试的时候,要么扭扭捏捏不够大方,无法表现自己的真实实力,要么口若悬河躁动不安,拿捏不准问题的实质,只得用不停的述说掩饰自己的紧张,适得其反……相信每个人都储存了一大堆这类不堪回首的往事。在最危急的时刻能保持极端的放松,不是一种技术,而是一种修养,是一种长期潜移默化修炼提升的结果。我们常说,某人胜就胜在心理上,或是说某人败就败在心理上。这其中的差池不是指在理性上,而是这种心灵张弛的韧性上。 没事的时候看看烟灰吧。他们曾经是火焰,燃烧过,沸腾过,但它们此刻安静了。它们毫不张扬地聚精会神地等待着下一次的乘风而起,携带着全部的能量,抵达阳光能到的任何地方。
那么代码如下
package main import ( "os" "fmt" "github.com/huichen/sego" ) func main() { // 载入词典 var segmenter sego.Segmenter segmenter.LoadDictionary("../src/github.com/huichen/sego/data/dictionary.txt") //读取文件内容到buf中 filename := "../src/test/Text" fp, err := os.Open(filename) defer fp.Close() if err != nil { fmt.Println(filename, err) return } buf := make([]byte, 4096) n, _ := fp.Read(buf) if n == 0 { return } // 分词 segments := segmenter.Segment(buf) // 处理分词结果 // 支持普通模式和搜索模式两种分词,见utils.go代码中SegmentsToString函数的注释。 // 如果需要词性标注,用SegmentsToString(segments, false),更多参考utils.go文件 output := sego.SegmentsToSlice(segments, false) //输出分词后的成语 for _, v := range output { if len(v) == 12 { fmt.Println(v) } } }
运行结果如下
整个工程的结构如下
郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。