精华内容
下载资源
问答
  • solr中文分词的种类

    2016-11-02 13:39:00
    上一篇讲了使用solr4.3自带的smartcn进行中文分词,这一篇说一下,怎么使用IK进行分词, 在这之前先对中文分词的种类介绍一下,目前的中文分词主要有两种 1,基于中科院ICTCLAS的隐式马尔科夫hhmm算法的中文分词器,...

    上一篇讲了使用solr4.3自带的smartcn进行中文分词,这一篇说一下,怎么使用IK进行分词,
    在这之前先对中文分词的种类介绍一下,目前的中文分词主要有两种
    1,基于中科院ICTCLAS的隐式马尔科夫hhmm算法的中文分词器,例如smartcn等。(不支持自定义扩展词库)
    2,基于正向迭代最细粒度切分算法(正向最大匹配并且最细分词)例如IK,庖丁等(支持自定义扩展词库)


    安装分词前,可以去
    http://code.google.com/p/ik-analyzer/downloads/list下载IK的分词包

    Java代码 复制代码 收藏代码
    1. ikanalyzer-4.3.1-SNAPSHOT.jar  
    ikanalyzer-4.3.1-SNAPSHOT.jar


    下载完毕后,将此包放进solr的\WEB-INF\lib下面

    Java代码 复制代码 收藏代码
    1. F:\eclipse10tomcat\webapps\solr\WEB-INF\lib  
    F:\eclipse10tomcat\webapps\solr\WEB-INF\lib




    下面需要在solr的schemal.xml进行分词器注册,给出代码如下

    Java代码 复制代码 收藏代码
    1. <!--  配置IK分词器 -->  
    2.     <fieldType name="text_ik" class="solr.TextField" positionIncrementGap="100">  
    3.       <analyzer type="index">  
    4.       <!--  分词-->  
    5.         <tokenizer class="org.wltea.analyzer.lucene.IKTokenizerFactory"/>  
    6.          <!--   禁用词过滤根据情况使用-->  
    7.         <!-- <filter class="org.wltea.analyzer.lucene.IKStopFilterFactory"/> -->  
    8.       </analyzer>  
    9.       <analyzer type="query">  
    10.        <!--  分词-->  
    11.         <tokenizer class="org.wltea.analyzer.lucene.IKTokenizerFactory"/>  
    12.         <!--   禁用词过滤根据情况使用-->  
    13.         <!-- <filter class="org.wltea.analyzer.lucene.IKStopFilterFactory"/>-->  
    14.       </analyzer>  
    15.     </fieldType>  
    <!--  配置IK分词器 -->
    	<fieldType name="text_ik" class="solr.TextField" positionIncrementGap="100">
          <analyzer type="index">
    	  <!--  分词-->
            <tokenizer class="org.wltea.analyzer.lucene.IKTokenizerFactory"/>
    		 <!--   禁用词过滤根据情况使用-->
    		<!-- <filter class="org.wltea.analyzer.lucene.IKStopFilterFactory"/> -->
          </analyzer>
          <analyzer type="query">
    	   <!--  分词-->
            <tokenizer class="org.wltea.analyzer.lucene.IKTokenizerFactory"/>
    		<!--   禁用词过滤根据情况使用-->
    		<!-- <filter class="org.wltea.analyzer.lucene.IKStopFilterFactory"/>-->
          </analyzer>
        </fieldType>



    最后还得配置一个引用字段就OK了

    Java代码 复制代码 收藏代码
    1. <field name="ik" type="text_ik" indexed="true" stored="true" multiValued="true"/>  
     <field name="ik" type="text_ik" indexed="true" stored="true" multiValued="true"/>



    然后访问UI管理器页面,可以使用Analysis进行中文切词分析测试,个人感觉IK的词库要比smartcn的词库大,不过两者各有优缺点,可以视具体业务情况而定,选择自己项目最合适的分词器。

    展开全文
  • 上一章ElasticSearch 连载一 基础入门 Elastic的概念、安装以及基础操作进行了介绍。 那是不是有童鞋会有以下几个问题呢? 什么是中文分词器? 分词怎么安装? 如何使用中文分词器? 那么...

    ElasticSearch 连载二 中文分词

    上一章ElasticSearch 连载一 基础入门 对Elastic的概念、安装以及基础操作进行了介绍。

    那是不是有童鞋会有以下几个问题呢?

    1. 什么是中文分词器?

    2. 分词器怎么安装?

    3. 如何使用中文分词器?

    那么接下来就为大家细细道来。

    什么是中文分词器

    搜索引擎的核心是 倒排索引 而倒排索引的基础就是分词。所谓分词可以简单理解为将一个完整的句子切割为一个个单词的过程。在 es 中单词对应英文为 term。我们简单看下面例子:

    我爱北京天安门

    ES 的倒排索引即是根据分词后的单词创建,即 北京天安门这4个单词。这也意味着你在搜索的时候也只能搜索这4个单词才能命中该文档。

     

    分词器安装

    首先,安装中文分词插件。这里使用的是 ik

    ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v5.5.1/elasticsearch-analysis-ik-5.5.1.zip

    上面代码安装的是5.5.1版的插件,与 Elastic 5.5.1 配合使用。

    安装结束后,会发现目录 /elasticsearch-5.5.1/plugins 多了一个analysis-ik 的文件。

    接着,重新启动 Elastic ,就会自动加载这个新安装的插件。

    最简单的测试

    用下面命令测试一下ik分词器:

    curl -X GET 'http://localhost:9200/_analyze?pretty&analyzer=ik_smart' -d '我爱北京天安门'

    返回结果:

    {
      "tokens" : [
        {
          "token" : "",
          "start_offset" : 0,
          "end_offset" : 1,
          "type" : "CN_CHAR",
          "position" : 0
        },
        {
          "token" : "",
          "start_offset" : 1,
          "end_offset" : 2,
          "type" : "CN_CHAR",
          "position" : 1
        },
        {
          "token" : "北京",
          "start_offset" : 2,
          "end_offset" : 4,
          "type" : "CN_WORD",
          "position" : 2
        },
        {
          "token" : "天安门",
          "start_offset" : 4,
          "end_offset" : 7,
          "type" : "CN_WORD",
          "position" : 3
        }
      ]
    }

    那么恭喜你,完成了ik分词器的安装。

     

    如何使用中文分词器

    概念

    这里介绍下 什么是_all字段, 其实all字段是为了在不知道搜索哪个字段时,使用的。ES会把所有的字段(除非你手动设置成false),都放在all中,然后通过分词器去解析。当你使用query_string的时候,默认就在这个_all字段上去做查询,而不需要挨个字段遍历,节省了时间。

    properties中定义了特定字段的分析方式

    • type,字段的类型为string,只有string类型才涉及到分词,像是数字之类的是不需要分词的。

    • store,定义字段的存储方式,no代表不单独存储,查询的时候会从_source中解析。当你频繁的针对某个字段查询时,可以考虑设置成true。

    • term_vector,定义了词的存储方式,with_position_offsets,意思是存储词语的偏移位置,在结果高亮的时候有用。

    • analyzer,定义了索引时的分词方法

    • search_analyzer,定义了搜索时的分词方法

    • include_in_all,定义了是否包含在_all字段中

    • boost,是跟计算分值相关的。

     

    添加Index

    然后,新建一个 Index,指定需要分词的字段。这一步根据数据结构而异,下面的命令只针对本文。基本上,凡是需要搜索的中文字段,都要单独设置一下。

    curl -X PUT 'localhost:9200/school' -d '
    {
      "mappings": {
        "student": {
            "_all": {
                "analyzer": "ik_max_word",
                "search_analyzer": "ik_max_word",
                "term_vector": "no",
                "store": "false"
            },
          "properties": {
            "user": {
              "type": "text",
              "analyzer": "ik_max_word",
              "search_analyzer": "ik_max_word",
              "include_in_all": "true",
              "boost": 8
            },
            "desc": {
              "type": "text",
              "analyzer": "ik_max_word",
              "search_analyzer": "ik_max_word",
              "include_in_all": "true",
              "boost": 10
            }
          }
        }
      }
    }'

    上面代码中,首先新建一个名称为school的 Index,里面有一个名称为student的 Type。student有三个字段。

    • user

    • desc

    这两个字段都是中文,而且类型都是文本(text),所以需要指定中文分词器,不能使用默认的英文分词器。

    上面代码中,analyzer是字段文本的分词器,search_analyzer是搜索词的分词器。ik_max_word分词器是插件ik提供的,可以对文本进行最大数量的分词。

     

    数据操作

    创建好了Index后,我们来实际演示下:

    新增记录

    curl -X PUT 'localhost:9200/school/student/1' -d '
    {
      "user": "许星星",
      "desc": "这是一个不可描述的姓名"
    }'
    curl -X PUT 'localhost:9200/school/student/2' -d '
    {
      "user": "天上的星星",
      "desc": "一闪一闪亮晶晶,爸比会跳舞"
    }'
    curl -X PUT 'localhost:9200/school/student/3' -d '
    {
      "user": "比克大魔王",
      "desc": "拿着水晶棒,亮晶晶的棒棒。"
    }'

    返回数据:

    {
        "_index": "school",
        "_type": "student",
        "_id": "3",
        "_version": 2,
        "result": "updated",
        "_shards": {
            "total": 2,
            "successful": 1,
            "failed": 0
        },
        "created": false
    }

    全文搜索

    Elastic 的查询非常特别,使用自己的查询语法,要求 GET 请求带有数据体。

    curl 'localhost:9200/school/student/_search'  -d '
    {
      "query" : { "match" : { "desc" : "晶晶" }}
    }'

    上面代码使用 Match 查询,指定的匹配条件是desc字段里面包含"晶晶"这个词。返回结果如下。

    {
        "took": 7,
        "timed_out": false,
        "_shards": {
            "total": 5,
            "successful": 5,
            "failed": 0
        },
        "hits": {
            "total": 2,
            "max_score": 2.5811603,
            "hits": [
                {
                    "_index": "school",
                    "_type": "student",
                    "_id": "3",
                    "_score": 2.5811603,
                    "_source": {
                        "user": "比克大魔王",
                        "desc": "拿着水晶棒,亮晶晶的棒棒。"
                    }
                },
                {
                    "_index": "school",
                    "_type": "student",
                    "_id": "2",
                    "_score": 2.5316024,
                    "_source": {
                        "user": "天上的星星",
                        "desc": "一闪一闪亮晶晶,爸比会跳舞"
                    }
                }
            ]
        }
    }

    Elastic 默认一次返回10条结果,可以通过size字段改变这个设置。

    curl 'localhost:9200/school/student/_search'  -d '
    {
      "query" : { "match" : { "desc" : "晶晶" }},
      "size" : 1
    }'

    上面代码指定,每次只返回一条结果。

    还可以通过from字段,指定位移

    curl 'localhost:9200/school/student/_search'  -d '
    {
      "query" : { "match" : { "desc" : "晶晶" }},
      "size" : 1,
      "from" : 1
    }'

    上面代码指定,从位置1开始(默认是从位置0开始),只返回一条结果。

     

    逻辑运算

    如果有多个搜索关键字, Elastic 认为它们是or关系。

    curl 'localhost:9200/school/student/_search'  -d '
    {
      "query" : { "match" : { "desc" : "水晶棒 这是" }}
    }'

    返回结果:

    {
        "took": 8,
        "timed_out": false,
        "_shards": {
            "total": 5,
            "successful": 5,
            "failed": 0
        },
        "hits": {
            "total": 2,
            "max_score": 5.1623206,
            "hits": [
                {
                    "_index": "school",
                    "_type": "student",
                    "_id": "3",
                    "_score": 5.1623206,
                    "_source": {
                        "user": "比克大魔王",
                        "desc": "拿着水晶棒,亮晶晶的棒棒。"
                    }
                },
                {
                    "_index": "school",
                    "_type": "student",
                    "_id": "1",
                    "_score": 2.5811603,
                    "_source": {
                        "user": "许星星",
                        "desc": "这是一个不可描述的姓名"
                    }
                }
            ]
        }
    }

     

    如果要执行多个关键词的and搜索,必须使用布尔查询

    curl 'localhost:9200/school/student/_search'  -d '
    {
      "query": {
        "bool": {
          "must": [
            { "match": { "desc": "水晶棒" } },
            { "match": { "desc": "亮晶晶" } }
          ]
        }
      }
    }'

    返回结果:

    {
        "took": 24,
        "timed_out": false,
        "_shards": {
            "total": 5,
            "successful": 5,
            "failed": 0
        },
        "hits": {
            "total": 1,
            "max_score": 10.324641,
            "hits": [
                {
                    "_index": "school",
                    "_type": "student",
                    "_id": "3",
                    "_score": 10.324641,
                    "_source": {
                        "user": "比克大魔王",
                        "desc": "拿着水晶棒,亮晶晶的棒棒。"
                    }
                }
            ]
        }
    }

     

    总结

    本章介绍了分词器的基本概念和使用,至此Elastic算是有一个基本的入门,下一章节将进一步学习分词器的特性以及场景案例。

     

    原文地址

    https://github.com/WilburXu/blog/blob/master/ElasticSearch/ElasticSearch%20%E8%BF%9E%E8%BD%BD%E4%BA%8C%20%E4%B8%AD%E6%96%87%E5%88%86%E8%AF%8D.md

    转载于:https://www.cnblogs.com/wilburxu/p/11129999.html

    展开全文
  • 分词 | 概率最大中文分词python实现

    千次阅读 2018-10-22 16:21:09
    首先解释一下累计概率怎么计算:假如待分词的句子为“对外经济技术合作与交流不断扩大。”,候选词可能有“”、“对外”、“外”、“经济”等。对于每个词的累计概率,等于它原来的概率乘上累计概率最大的左邻词的...

    摘要

    概率最大分词是分词的其中一种算法,通过选出句子中所有的候选词,计算它们的累计概率,在不同的词语组合中选出累计概率最大的组合作为最终的分词结果。这里使用python进行实现。

    算法描述

    首先解释一下累计概率怎么计算:假如待分词的句子为“对外经济技术合作与交流不断扩大。”,候选词可能有“对”、“对外”、“外”、“经济”等。对于每个词的累计概率,等于它原来的概率乘上累计概率最大的左邻词的概率,即P’(wi) = P(wi) * P(wi-1),对于作为句子起始的单词则是他本身的概率。

    例如:P’(对) = P(对),P’(对外) = P(对外)。P’(外) = P(外) * P(对),P’(经济) = P(经济) * max{P’(外) , P’(对外)},以此类推。

    具体算法描述如下:

    1. 首先需要将句子按从左到右的顺序取出全部候选词w1,w2,…,wn;
    2. 计算每个候选词的概率值,并记录它的左邻词;
    3. 接着计算每个候选词的累计概率,累计概率最大的候选词为最佳左邻词;
    4. 如果wn为句子的尾词,且累计概率P’(wn)最大,则wn为句子终点词;
    5. 从wn开始,按从左到右的顺序,依次将每个词的最佳左邻词输出,即为句子的分词结果。

    当句子很长的时候,句子的切分方式就很多,因此计算概率的次数和所消耗的内存空间就会很大,因此使用动态规划的方式来编写此算法。

    使用列表dp[i]表示sentence[0, i](在python中为sentence[0: i+1],这里为了方便说明)的所有切分的最大概率,root[]记录使得dp[i]最大的词的起始坐标。使用word_tail表示尾词或当前词的下标,root[word_tail]则表示该词的起始下标。

    详例描述

    设置我们搜寻候选词的最大长度max_len = 4,初始化dp[],root[]长度为句子长度,每项均为0。
    sentence = ‘对外经济技术合作与交流不断扩大。’

    1. word = ‘对’,查找词典中‘对’的概率为0.003388;
    2. dp[0] = 0.003388表示sentence[0, 0]当前的最大概率,root[0] = 0表示sentence[0]的词的起始下标为0;
    3. word = ‘对外’,查找词典中‘对’的概率为7.5e-05;
    4. dp[1] = 7.5e-05,表示sentence[0, 1]当前的最大概率;root[1] = 0,表示“对外”的起始下标为0,即“对外”此时为累计概率最大的词;
    5. ‘对外经’,‘对外经济’在词典中没有,故跳过;
    6. word = ‘外’,概率为0.00025,需要计算其累计概率P’(外) = P(外) * P’(对) = 0.00025 * dp[0],判断其是否大于dp[1],即是否大于P’(对外),若是,则替换dp[1],并将root[1]改为1。当此处为小于,故不会替换,跳过;
    7. 后面以此类推,再通过root[]记录的下标从尾词开始向前找概率最大的左邻词。

    当句子过长时,概率相乘到最后会很小可能会导致溢出问题,故将概率取自然对数P(W)* = -lnP(W) = Σ[-lnP(wi)],于是求最大值问题就变成了求最小值问题。只需要在获取词典的时候取自然对数,并在计算累计概率时改为相加即可。

    实现代码

    首先是加载字典

    # 获得词-词频字典
    def get_dict(path):
        pro_dict = {}
        with open(path, 'r') as r:
            lines = r.readlines()
            for line in lines:
                sub = line.split(',')
                # 对概率取自然对数和负号
                # 使最大值问题转化为最小值问题
                pro_dict[sub[0]] = -math.log(float(sub[2].strip('\n')[:-1]) / 100)
        return pro_dict
    
    
    max_len = 4 
    

    分词算法

    def max_pro(sentence):
        pro_dict = get_dict('WordFrequency.txt')
        dp = [999] * len(sentence)  # dp[i]表示sentence[0: i+1]的最大概率
        root = [0] * len(sentence)  # root[i]表示sentence[i]的词的起始下标
        for i in range(len(sentence)):
            for j in range(i, i+max_len):
                if j < len(sentence):
                    word = sentence[i: j+1]
                    # print(word)
                    if word in pro_dict.keys():
                        temp_pro = pro_dict[word]
                        print(word, temp_pro)
                        if i > 0:
                            temp_pro += dp[i-1]
                        if temp_pro < dp[j]:
                            dp[j] = temp_pro
                            root[j] = i
                else:
                    break
        # 输出结果
        result = []
        word_tail = len(sentence) - 1
        while word_tail >= 0:
            result.append(sentence[root[word_tail]: word_tail + 1])
            word_tail = root[word_tail] - 1
        result.reverse()
        return dp, root, result
    

    主函数,测试了分词的具体时间,包括了加载字典所需要的时间

    if __name__ == '__main__':
        start = time.time()
        dp, root, result = max_pro('对外经济技术合作与交流不断扩大。')
        # print(dp)
        # print(root)
        print(result)
        end = time.time()
        print("running time: " + str(end - start) + "s")
    
    展开全文
  • 在基于Lucene的搜索系统 同时使用Paoding进行中文分词 一 中讲解了利用lucene建立索引的过程以及搜索条件,和结果封装,今天来看客户端是怎么调用透露给外部的servlet的 项目结构如上图 其中search报下的 ...

    在基于Lucene的搜索系统 同时使用Paoding进行中文分词 一 中讲解了利用lucene建立索引的过程以及对搜索条件,和结果封装,今天来看客户端是怎么调用透露给外部的servlet的

    项目结构如上图

    其中search报下的

    这几个类就不做说明了 ,可以在基于Lucene的搜索系统 同时使用Paoding进行中文分词 一 找到

    上代码:

    LIstGood.java

    package com.ajun.servlet;
    
    import java.io.IOException;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import com.ajun.search.SearchResultInfo;
    import com.ajun.utils.SearchUtil;
    
    /**
     * 
     * @author ajun
     *
     */
    public class ListGood extends HttpServlet {
    
    	/**
    	 * The doGet method of the servlet. <br>
    	 *
    	 * This method is called when a form has its tag value method equals to get.
    	 * 
    	 * @param request the request send by the client to the server
    	 * @param response the response send by the server to the client
    	 * @throws ServletException if an error occurred
    	 * @throws IOException if an error occurred
    	 */
    	public void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		this.doPost(request, response);
    	}
    
    	/**
    	 * The doPost method of the servlet. <br>
    	 *
    	 * This method is called when a form has its tag value method equals to post.
    	 * 
    	 * @param request the request send by the client to the server
    	 * @param response the response send by the server to the client
    	 * @throws ServletException if an error occurred
    	 * @throws IOException if an error occurred
    	 */
    	public void doPost(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		String condition = request.getParameter("condition");//接受页面传递过来的条件参数此时已经瓶装好了,如果不想拼装还可以单独接受
    		if(condition!=null){
    			condition = new String(condition.getBytes("ISO-8859-1"),"UTF-8");
    		}
    		SearchResultInfo restule = SearchUtil.getResultObjectFromJson(condition);//返回封装好搜索结果对象
    		request.setAttribute("result", restule);
    		request.setAttribute("condition", condition);
    		request.getRequestDispatcher("/index.jsp").forward(request, response);
    		
    	}
    
    }
    

    HttpTool.java

    package com.ajun.utils;
    
    import java.io.BufferedReader;
    import java.io.DataOutputStream;
    import java.io.InputStreamReader;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.util.regex.Pattern;
    /**
     * Http操作辅助工具
     * @author ajun
     *
     */
    public class HttpTool {
    	/**
    	 * GET请求数据
    	 * @param get_url url地址
    	 * @param content  key=value形式
    	 * @return 返回结果
    	 * @throws Exception
    	 */
    	public String sendGetData(String get_url, String content) throws Exception {
    		String result = "";
    		URL getUrl = null;
    		BufferedReader reader = null;
    		String lines = "";
    		HttpURLConnection connection = null;
    		try {
    			if (content != null && !content.equals(""))
    				get_url = get_url + "?" + content;
    				//get_url = get_url + "?" + URLEncoder.encode(content, "utf-8");
    			getUrl = new URL(get_url);
    			connection = (HttpURLConnection) getUrl.openConnection();
    			connection.connect();
    			// 取得输入流,并使用Reader读取
    			reader = new BufferedReader(new InputStreamReader(connection
    					.getInputStream(), "utf-8"));// 设置编码
    			while ((lines = reader.readLine()) != null) {
    				result = result + lines;
    			}
    			return result;
    		} catch (Exception e) {
    			throw e;
    		} finally {
    			if (reader != null) {
    				reader.close();
    				reader = null;
    			}
    			connection.disconnect();
    		}
    	}
    	/**
    	 * @param POST_URL url地址
    	 * @param content  key=value形式
    	 * @return 返回结果
    	 * @throws Exception
    	 */
    	public String sendPostData(String POST_URL, String content)
    			throws Exception {
    		HttpURLConnection connection=null;
    		DataOutputStream out=null;
    		BufferedReader reader=null;
    		String line = "";
    		String result="";
    		try {
    			URL postUrl = new URL(POST_URL);
    			connection= (HttpURLConnection) postUrl.openConnection();
    			connection.setDoOutput(true);
    			connection.setDoInput(true);
    			connection.setRequestMethod("POST");
    			// Post 请求不能使用缓存
    			connection.setUseCaches(false);
    			connection.setInstanceFollowRedirects(true);
    			connection.setRequestProperty("Content-Type",
    					"application/x-www-form-urlencoded");
    			connection.connect();
    			
    			out = new DataOutputStream(connection.getOutputStream());
    			//content = URLEncoder.encode(content, "utf-8");
    			// DataOutputStream.writeBytes将字符串中的16位的unicode字符�?8位的字符形式写道流里�?
    			out.writeBytes(content);
    			out.flush();
    			out.close();
    			//获取结果
    			reader = new BufferedReader(new InputStreamReader(
    					connection.getInputStream(), "utf-8"));// 设置编码
    			while ((line = reader.readLine()) != null) {
    				result=result+line;
    			}		
    			return result;
    		} catch (Exception e) {
    			throw e;
    		}finally
    		{
    			if(out!=null)
    			{
    				out.close();
    				out=null;				
    			}
    			if(reader!=null)
    			{
    				reader.close();
    				reader=null;				
    			}
    			connection.disconnect();
    		}
    	}
    	/*
    	 * 过滤掉html里不安全的标签,不允许用户输入这些标�?
    	 */
    	public static String htmlFilter(String inputString) {
    		//return inputString;
    		  String htmlStr = inputString; // 含html标签的字符串
    		  String textStr = "";
    		  java.util.regex.Pattern p_script;
    		  java.util.regex.Matcher m_script;
    		 	
    		
    		  try {
    		   String regEx_script = "<[\\s]*?(script|style)[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?(script|style)[\\s]*?>"; 
    		   String regEx_onevent="on[^\\s]+=\\s*";
    		   String regEx_hrefjs="href=javascript:";
    		   String regEx_iframe="<[\\s]*?(iframe|frameset)[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?(iframe|frameset)[\\s]*?>";
    		   String regEx_link="<[\\s]*?link[^>]*?/>";
    		  
    		   htmlStr = Pattern.compile(regEx_script, Pattern.CASE_INSENSITIVE).matcher(htmlStr).replaceAll(""); 
    		   htmlStr=Pattern.compile(regEx_onevent, Pattern.CASE_INSENSITIVE).matcher(htmlStr).replaceAll("");
    		   htmlStr=Pattern.compile(regEx_hrefjs, Pattern.CASE_INSENSITIVE).matcher(htmlStr).replaceAll("");
    		   htmlStr=Pattern.compile(regEx_iframe, Pattern.CASE_INSENSITIVE).matcher(htmlStr).replaceAll("");
    		   htmlStr=Pattern.compile(regEx_link, Pattern.CASE_INSENSITIVE).matcher(htmlStr).replaceAll("");
    		  
    		   //p_html = Pattern.compile(regEx_html, Pattern.CASE_INSENSITIVE);
    		  // m_html = p_html.matcher(htmlStr);
    		  // htmlStr = m_html.replaceAll(""); // 过滤html标签
    
    		   textStr = htmlStr;
    
    		  } catch (Exception e) {
    		   System.err.println("Html2Text: " + e.getMessage());
    		  }
    
    		  return textStr;
    		}
    }

    SearchUtil.java

    package com.ajun.utils;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import net.sf.json.JSONObject;
    
    import com.ajun.search.ConditionInfo;
    import com.ajun.search.ConditionMethod;
    import com.ajun.search.SearchItemInfo;
    import com.ajun.search.SearchResultInfo;
    
    /**
     * 
     * @author ajun
     *
     */
    public class SearchUtil {
    
    	/**
    	 * 返回结果集合
    	 * @param condition 条件对象
    	 * @return
    	 */
    	public static SearchResultInfo getResultObjectFromJson(ConditionInfo condition){
    		SearchResultInfo sr = null;
    		try {
    			String urlParams = ConditionMethod.getConditionUrl(condition);
    			String url = PubConstant.getValue("searchUrl")+urlParams;
    			String content = new HttpTool().sendGetData(url, "");
    			JSONObject  json = JSONObject.fromObject(content);
    			if(json!=null){
    				Map<String,Class> map = new HashMap<String,Class>();
    				map.put("itemLists", SearchItemInfo.class);
    				sr = (SearchResultInfo)JSONObject.toBean(json,SearchResultInfo.class,map);
    			}
    			System.out.println(json);
    		} catch (IllegalArgumentException e) {
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
    			e.printStackTrace();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return sr;
    	}
    	
    	public static SearchResultInfo getResultObjectFromJson(String conditionUrl){
    		SearchResultInfo sr = null;
    		try {
    			String url = PubConstant.getValue("searchUrl")+conditionUrl;
    			if(conditionUrl==null || "".equals(conditionUrl.trim())){
    				ConditionInfo c = new ConditionInfo();
    				url = ConditionMethod.getConditionUrl(c);
    			}
    			String content = new HttpTool().sendGetData(url, "");
    			JSONObject  json = JSONObject.fromObject(content);
    			if(json!=null){
    				Map<String,Class> map = new HashMap<String,Class>();
    				map.put("itemLists", SearchItemInfo.class);
    				sr = (SearchResultInfo)JSONObject.toBean(json,SearchResultInfo.class,map);
    			}
    			System.out.println(json);
    		} catch (IllegalArgumentException e) {
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
    			e.printStackTrace();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return sr;
    	}
    }
    

    PubConstant.java


    package com.ajun.utils;
    
    import java.io.IOException;
    import java.util.Properties;
    
    /*
     * @author ajun  
     * @date 2011-07-31
     */
    public class PubConstant {
    
    	private static Properties properties= new Properties();
    	static{
    		try {
    			properties.load(PubConstant.class.getClassLoader().getResourceAsStream("constant.properties"));
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	public static String getValue(String key){
    		String value = (String)properties.get(key);
    		return value.trim();
    	}
    }
    
     constant.properties

    mysql_Url=jdbc\:mysql\://127.0.0.1/goodsearch?useUnicode\=true&characterEncoding\=UTF-8
    mysql_UserName=xxxxx
    mysql_Password=xxxx
    
    searchUrl=http\://127.0.0.1\:8080/searcher/getResult?condition\=
    
    

    goodsearch.js用于条件对象和条件字符串的转换

    	/**
    	  *条件对象 
    	  * **/
    	 function  conditionInfo(){
    		 	this.keyWords='',
    		 	this.withoutWords='',
    		 	this.goodId='',
    		 	this.minPrice='',
    		 	this.maxPrice='',
    		 	this.orderbyName='uptime',
    		 	this.orderbyValue='desc',
    		 	this.pageSize='20',
    		 	this.pageIndex='1'
    	 }
    	 
    	 
    	  /**
    	  * 将action传递过来的condition字符串转换为conditionInfo js 对象
    	  * */
    	 function StrToConditionInfoObject(url){
    		 var urlStr =url;
    		 var obj = new conditionInfo();
    		 if(urlStr!=''){
    			var urls = urlStr.split('-',100);
    		 	obj.keyWords=urls[0];
    		 	obj.withoutWords=urls[1];
    		 	obj.goodId=urls[2];
    		 	obj.minPrice=urls[3];
    		 	obj.maxPrice=urls[4];
    		 	obj.orderbyName=urls[5];
    		 	obj.orderbyValue=urls[6];
    		 	obj.pageSize=urls[7];
    		 	obj.pageIndex=urls[8];
    		 }
    		 
    		 return obj;
    	 }
    	 
    	  /**
    	  *  条件对象转换为Url地址
    	  * param condition 条件对象
    	  * */
    	 function createUrl(condition){
    		 var con = '';
    		 var lastconInfo='';
    		for(var index in condition){
    			if(condition[index]==null || condition[index]==''){
    				con+=''+'-';
    			}else{
    				con+=condition[index]+'-';
    			}
    		}
    		if(con!=''){
    			lastconInfo = con.substring(0,con.length-1);
    		}
    		return lastconInfo;
    		//return encodeURI(lastconInfo);
    	 }
    	 
    	 /**
    	  * 搜索商品列表
    	  * @param {Object} conditionInfo 条件对象
    	  * @param {Object} action 提交url
    	  */
    	 function searchByCondition(conditionInfo,action){
    		  var url = createUrl(conditionInfo);
    		  //alert(url);
    		  document.location.href=action+'?condition='+url;	
    	 }


    index.jsp搜索页面

    <%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
    <%@ taglib prefix="c"  uri="http://java.sun.com/jsp/jstl/core" %>
    <%@ taglib prefix="fmt"  uri="http://java.sun.com/jsp/jstl/fmt" %>
    <%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
    %>
    
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
      <head>
        <base href="<%=basePath%>">
        
        <title>My JSP 'index.jsp' starting page</title>
    	<meta http-equiv="pragma" content="no-cache">
    	<meta http-equiv="cache-control" content="no-cache">
    	<meta http-equiv="expires" content="0">    
    	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    	<meta http-equiv="description" content="This is my page">
    	<!--
    	<link rel="stylesheet" type="text/css" href="styles.css">
    	-->
    	 <script type="text/javascript" src="script/jquery.min.js"></script>
    	 <script type="text/javascript" src="script/goodsearch.js"></script>
    	 <script type="text/javascript">
    	 	function search(){
    	 		var condition = StrToConditionInfoObject('${condition}');
    	 		if($.trim($('#keyWords').val())!=''){
    	 			condition.keyWords = $('#keyWords').val();
    	 			
    	 		}else{
    	 			condition.keyWords='';
    	 		}
    	 		if($.trim($('#minPrice').val())!=''){
    	 			condition.minPrice = $('#minPrice').val();
    	 			
    	 		}else{
    	 			condition.minPrice='0';
    	 		}
    	 		if($.trim($('#maxPrice').val())!=''){
    	 			condition.maxPrice = $('#maxPrice').val();
    	 			
    	 		}else{
    	 			condition.maxPrice='';
    	 		}
    	 		//condition.minPrice = '10.00';
    	 		searchByCondition(condition,'ListGood');
    	 	}
    	 </script>
      </head>
      
      <body>
        <table border="1">
        	<tr>
        		<td colspan="4">
        			GoodName:<input id="keyWords" value="" type="text"/><br/>
        			minPrice:<input id="minPrice" value="" type="text"/><br/>
        			maxPrice:<input id="maxPrice" value="" type="text"/><br/>
        			<input id="keyWords" value="Search" type="button" οnclick="search();"/>
        		</td>
        	</tr>
        	<tr>
        		<td>Id</td>
        		<td>Name</td>
        		<td>Price</td>
        		<td>Uptime</td>
        	</tr>
        	<c:forEach items="${result.itemLists}" var="item">
        		<tr>
    	    		<td>${item.id }</td>
    	    		<td>${item.name }</td>
    	    		<td>${item.price }</td>
    	    		<td>2010-09-09</td>
    	    	</tr>
        	</c:forEach>
        </table>
      </body>
    </html>
    

    效果如下:

    大家可以不用goodsearch.js

    条件参数可以直接传递到后台 ,然后在后台接受 ,set到ConditionInfo对象就可以了


    源码可以在我的资源中进行下载


    展开全文
  • 最近正在用nltk 对中文网络商品评论进行褒贬情感分类,计算评论的信息熵(entropy)、互信息(point mutual information)和困惑值(perplexity)等(不过这些概念我其实也还理解不深...只是nltk 提供了相应方法)。...
  • 上一篇讲了使用solr4.3自带的smartcn进行中文分词,这一篇说一下,怎么使用IK进行分词, 在这之前先对中文分词的种类介绍一下,目前的中文分词主要有两种 1,基于中科院ICTCLAS的隐式马尔科夫hhmm算法的中文分词器...
  • 我们需要输入的东西进行分词。这个ES已经考虑过了,所以它内置了一些分词器,但是中国文化,博大精深,有时候自己断句都会有误差,所以我们会用一些国人的插件进行中文分词。这篇文章的重点也就是介绍ES分词原理、...
  • 序列标注 | (8) 中文分词评估指标

    千次阅读 2020-06-02 09:55:31
    原文地址 1. 背景 NLP中一个最基本任务就是分词,当我们分词完成之后怎么来评判分词结果的好坏呢?换句话来说就是我该如何对分词结果打分?...举个例子,比如现在有一个猫狗图片分类器100张图片进行分类,分
  • 学习elasticsearch时,当进行精确查询时候,我们发现无法对中文词汇进行有效的检索。但是对单个字进行查询却能检索得到。 查询好人没有结果,查询如果换成“好”,“李白是个大好人”就被查到了。 问题的原因 要...
  • 一,标记问题解决分词:就是将 词语开始和结束的字标记出来,就能一个句子完成分词,假设使用两个标记B (开始),E(结束)句子进行处理,如:“民主是普世价值”,民B主E是B普B世E价B值E, 这样标记明确,分词结果...
  • 不知怎么,好像与文本挖掘有缘,今再次碰到了。倒腾了一晚上,这两个包算是安装成功了。 一般步骤:安装JAVA成功后,才能安装Rjava,Rwordseg包也才能安装成功。1.到oracle官网下载JDK,注意要和电脑配对,查明电脑...
  • ICTCLAS分词系统的使用

    2015-05-31 12:27:11
    怎么用ICTCLAS分词系统一个TXT文档里面的所有中文语料进行分词操作,求大神指点,越详细越好
  • Elasticsearch-analysis-ik分词器的安装及使用前面我们讲到...Elasticsearch 内置的分词对中文不友好,会把中文分成单个字来进行全文检索,不能达到想要的结果,在全文检索及新词发展如此快的互联网时代,IK可以进...
  • 在用jieba分词之后,出现大概下面的句子: x/ 漂亮a/ ,x/ 古典ns/ 园林n/ ,x/ 超赞v/ , 想将每一个x/.../,作为一个整体,同时分出来的词进行词频统计。求指教,急...
  • Lucene.Net 对中文的支持不好这是不争的事实,即使能对中文分词也只是两两组合,即比如说一个字符串“我爱博客园,我爱编程”,那么使用Lucene.Net 分词后变成 下面这些词: 我爱 爱博 博客 客园 我爱 爱编 ...
  • 遇到了个麻烦想了很久 Lucene做全文检索的时候 句子用IKAnalyzer 分词 ...我现在是 搜索的输入也进行分词 这样会导致 搜索 “百度公司” 时 被分为了 百度|公司 然后 腾讯公司 这个结果也出来了
  • 对于通⽤领域,可以多种分词工具和多种句法短语⼯具进行融合来提取候选实体,并结合词典进行NER。 此外,怎么更好地将实体词典融入到NER模型中,也是一个值得探索的问题(如嵌入到图神经网络中提取特征[3])。 ...
  • [转]基于大规模语料的新词发现算法

    千次阅读 2015-01-22 18:35:51
    对中文资料进行自然语言处理时,我们会遇到很多其他语言不会有的困难,例如分词——汉语的词与词之间没有空格,那计算机怎么才知道“已结婚的和尚未结婚的”究竟是“已/结婚/的/和/尚未/结婚/的”,还是“已/...
  • 其中,参数 seg 表示 synonyms.compare 是否 sen1 和 sen2 进行分词,默认为 True。返回值:[0-1],并且越接近于 1 代表两个句子越相似。 旗帜引领方向 vs 道路决定命运: 0.429 旗帜引领方向 vs 旗帜指引道路: ...
  • 系统学习机器学习之随机场(一)--HMM

    千次阅读 2015-12-26 15:08:18
    HMM(隐马尔科夫模型)是自然语言处理中的一个基本模型,用途比较广泛,如汉语分词、词性标注及语音识别等,在NLP中占有...例子我借助中文wiki重新翻译了一下,并三大基本问题进行说明,希望读者朋友有所帮助:  Al
  • 特征工程

    2020-06-26 20:14:04
    文本数据可先进行分词,再以根据需求以下列方法进行(分词是以空格分隔每个词,对于英文文本无需分词,对于中文文本可用分词工具进行分词,如jieba) 计数 将文本中出现的所有词按出现次数统计,不统计单个字符 ...
  • 要想使得一个搜索系统更加的完美,查询精确度和页面显示算是其中比较重要的两个方面。今天,我们就来谈谈怎么使得我们的搜索系统更加的完美。...JE-Analysis,下载地址配置我们使用xml的方式对分词进行
  • 基于大规模语料的新词发现算法

    千次阅读 2016-02-01 09:44:55
    对中文资料进行自然语言处理时,我们会遇到很多其他语言不会有的困难,例如分词——汉语的词与词之间没有空格,那计算机怎么才知道“已结婚的和尚未结婚的”究竟是“已/结婚/的/和/尚未/结婚/的”,还
  • 对中文资料进行自然语言处理时,我们会遇到很多其他语言不会有的困难,例如分词——汉语的词与词之间没有空格,那计算机怎么才知道“已结婚的和尚未结婚的”究竟是“已/结婚/的/和/尚未/结婚/的”,还是“已/...

空空如也

空空如也

1 2 3 4
收藏数 74
精华内容 29
关键字:

怎么对中文进行分词