精华内容
下载资源
问答
  • 现有的XML关键字查询方法包括两步:确定满足特定语义的节点; 构建满足特定条件的子树。这种处理方式需要多次扫描关键字倒排表, 效率低下。针对这一问题, 提出快速分组方法来减少扫描倒排表次数, 进而基于快速分组...
  • 查询Q = { k1, k2, k3 } stack算法求SLCA 基本思想:先序遍历后序(自底向上)处理所有包含关键字的结点 从小到大遍历k1,k2两个关键字倒排表中的编码,依次入栈,比较相邻编码,编码中不同部分出栈,出栈时判断其...


              XML文档树                       树中每个结点对应唯一ID号

     

    概念:

    (1)SLCA结点:最小的包含所有关键字的结点

         对于查询Q = { a,b}来说SCLA结点有:x1, x4

    (2)ELCA结点:在排除以它的后代结点为根的子树中所有关键字之后以它为根的子树仍然包含所有查询关键字

         对于查询Q = { a,b}来说, ELCA结点有:x1, x2, x4

     

    一、求解所有的SLCA(最小最低公共祖先)结点

    (1)stack算法

            基本思想:先序遍历、后序(自底向上)处理所有包含关键字的结点

             1. 从小到大遍历a, b两个关键字倒排表中的编码,依次入栈,比较相邻编码,编码中不同部分出栈,出栈时判断其

                是否为真正的SLCA;

             2. 判断一个结点是否为SLCA结点,需要知道其包含查询关键字的情况。若其没有包含所有关键字,则将包含关键

                 字的信息传递给其父亲;若其包含所有关键字,则其是一个候选的SLCA(事实上第一个候选SLCA就是一个真

                 正的SLCA),其包含关键字的信息不传递给其父亲; 

             3. 按照上面的过程求出下一个候选的SLCA,判断其与前一个SLCA之间的祖先后代关系,若不是祖先后代关系,则

                 说明其是一个真正的SLCA.


    (2)IL算法

            基本思想

            1. 比较a,b两个关键字倒排表的长度,依次取最短倒排表中的一个编码到次短倒排表中求左右匹配;

                左匹配:比该编码小的最大的编码,右匹配:比该编码大的最小的编码

            2. 该编码分别和左右匹配得到两个LCA结点,其中编码较长的LCA结点为候选的SLCA结点;

              (若还有第三个关键字,则拿该LCA结点到最长倒排表中求左右匹配,同理得到两个LCA结点,其中编码较长

                的LCA 结点为候选的SLCA结点)

            3. 处理最短倒排中的第二个编码,同理得到一个候选的SLCA结点,根据它们的祖先后代关系判断前一个候选SLCA

                结点是否为真正的SLCA结点。

     

    IL算法Stack算法的不同点:

               IL算法从左到右遍历最短倒排表,用一个候选SLCA判断前一个候选SLCA是否为真正的SLCA结点;

               Stack算法自底向上进行求解,一个候选SLCA判断后一个候选SLCA是否为真正的SLCA结点。

     

    二、求解所有的ELCA(排他的最低公共祖先)结点

    HashCount算法

           基本思想

            1. 建立关键字的hashcount索引,记录某个结点包含关键字的个数;

            2. 比较a,b两个关键字倒排表的长度,依次取最短倒排表中的一个编码入栈,比较相邻编码,编码中不同部分出栈

                ,出栈时根据其包含关键字个数情况判断其是否为真正的ELCA;

            3. 若是ELCA结点,则需要将其包含关键字个数信息传递给父亲结点;若不是ELCA结点,说明其父亲结点是一个潜

               在的ELCA结点;

            4. 直至最短倒排表被遍历完为止。

    展开全文
  • 最后,使用Enron电子邮件数据集作为实验数据库,分别在索引时间成本、暗门生成时间成本和查询时间方面评估了该算法的检索和保密性能。实验结果表明,该算法可在云计算中进行高效的加密多关键字排列检索。
  • 1.1 静态查找表1、查询某个特定元素是否在查找表的集合当中2、查询某个特定元素的各种属性1.2 动态查找表1、在查找表中插入一个数据元素2、在查找表中删除一个元素1.3 关键字它是数据元素的某个数据项的值。...

    53db61a4cd0f8e922f561c214f6883b1.png

    1、查找表和查找效率的概念

    查找表是指由同一类型的数据元素构成的集合。分为静态查找表和动态查找表。

    1.1 静态查找表

    1、查询某个特定元素是否在查找表的集合当中2、查询某个特定元素的各种属性

    1.2 动态查找表

    1、在查找表中插入一个数据元素2、在查找表中删除一个元素

    1.3 关键字

    它是数据元素的某个数据项的值。用来识别该元素。主关键字是唯一能表示该元素的值。次关键字用来表示多个数据元素的关键字。

    1.4 查找

    根据给定的值在查找表中查询是否存在一个其关键字等于给定值的记录或者数据元素。

    1.5 平均查找长度

    关键字和给定值进行比较的记录个数的平均值。也是衡量查找算法好坏的依据。

    2、顺序查找

    从数据集合的一端,逐个记录的关键字和给定值进行比较,找到则为查找成功。整个数据集合比较完后仍然找不到,则为查找失败。顺序查找适用于顺序存储和链式存储。其平均查找长度为(n+1)/2.顺序查找算法简单、适应性广。当数据集合数据量大的话,查询效率会较低。

    3、折半查找

    折半查找也称为二分查找。平均查找长度:(n+1)/n*log^2(n+1) -1,当n值较大 log^2(n+1) -1折半查找效率比顺序查找高,它比较合适顺序存储和关键字有序排列。所以折半查找适合数据表不经常变动,查询频率较高的情况。       741fb88d8676c4a8f00627a27090de1d.png      

    4、索引顺序查找

    索引顺序查找又称为分块查找,是顺序查找的一个改进查找算法。原理:分块查找首先将表分为若干块。每一块可以无序。但块之间是要有序的。即后一块所记录的关键字均大于前一块的关键字。另外还会创建一个索引块表,索引块表关键字有序。查询过程:1、在索引表中确认待查记录所在数据块。2、在该数据块内顺序查找。平均查找长度:1/2(n/s + s) +1它的效率优于顺序查找,比不上折半查找。

    5、树表查找

    常见的树表查找有二叉查找树、B-树、红黑树等常见查找算法。二叉查找树是一种动态查找表

    5.1 二叉查找树查找过程

    利用二叉查找树左小右大的特性,可以很容易实现查找任意值和最大/小值。在二叉查找树中查找一个给定的关键字n的过程与折半查找很类似,查找过程如下:1.若二叉树是空树,则查找失败。2.若x等于根节点的数据,则查找成功,否则。3.若x小于根节点的数据,则递归查找其左子树,否则。4.递归查找其右子树。

    5.2 二叉树查找树b插入操作x的过程

    1.若b是空树,则直接将插入的节点作为根节点插入。2.x等于b的根节点的数据的值,则直接返回,否则。3.若x小于b的根节点的数据的值,则将x要插入的节点的位置改变为b的左子树,否则。4.将x要插入的节点的位置改变为b的右子树。注:如果二叉树是单枝树。查询效率和顺序查找相当。

    6、哈希查找

    6.1 概念

    通过计算数据元素的存储地址进行元素查找的一种查找算法。根据设定的哈希函数和处理冲突的方法,将一组关键字映射到一个有限的连续的地址集上,并以关键字在地址集中的“像”作为记录在表中的存储位置,这种表称为哈希表。这一映射过程称为哈希造表或散列。所得的存储位置称为哈希位置或者散列地址。哈希算法要解决两个问题:哈希函数的构造、冲突的解决。

    6.2 解决冲突

    解决冲突就是为出现冲突的关键字找到另一个“空”的哈希地址。常用的解决冲突的方法有:开放定址法、链地址法、再哈希法、建立公共溢区法。

    6.2.1开放定址法

    最简单的产生探测序列的方法是进行线性探测,发生冲突后,顺序到下一个存储单元进行探测。

    6.2.2 链地址法

    链地址法是常用并且很有效的方法。它将具有相同哈希函数值记录组成一个链表,当链域值为NULL时,表示没有后继记录。

    6.2.3 哈希查找

    线性探测解决冲突的方式下:某一个位置上找到关键字等于key的记录,表示查找成功;探测序列查不到key关键字的记录,又遇到了空单元,表示找不到该元素,查找失败。链地址法解决冲突构造的哈希表中查找元素,就是根据哈希函数得到的元素所在链表的头指针,然后在链表中顺序查找的过程。

    IT技术分享社区

    个人博客网站:https://programmerblog.xyz

    48253e8c414856ffd631e6287dcbe4d5.png

    文章推荐程序员效率:画流程图常用的工具程序员效率:整理常用的在线笔记软件远程办公:常用的远程协助软件,你都知道吗?51单片机程序下载、ISP及串口基础知识硬件:断路器、接触器、继电器基础知识
    展开全文
  • 提出了基于结果类型分组的XML(extensible markup language,可扩展标志语言)关键字查询算法。采用熵值赋权法确定结果类型,继而对XML文档节点虚拟分组,并在虚拟组的基础上给出了相应的查询算法,不仅确保了结果信息...
  • 前言敏感词过滤应该是不用给大家过多的解释吧?讲白了就是你在项目中输入某些字(比如输入xxoo相关的文字时)时要能检测出来...敏感词过滤的做法有很多,我简单描述我现在理解的几种:①查询数据库当中的敏感词,循环...

    前言

    敏感词过滤应该是不用给大家过多的解释吧?讲白了就是你在项目中输入某些字(比如输入xxoo相关的文字时)时要能检

    测出来,很多项目中都会有一个敏感词管理模块,在敏感词管理模块中你可以加入敏感词,然后根据加入的敏感词去过滤输

    入内容中的敏感词并进行相应的处理,要么提示,要么高亮显示,要么直接替换成其它的文字或者符号代替。

    敏感词过滤的做法有很多,我简单描述我现在理解的几种:

    ①查询数据库当中的敏感词,循环每一个敏感词,然后去输入的文本中从头到尾搜索一遍,看是否存在此敏感词,有则做相

    应的处理,这种方式讲白了就是找到一个处理一个。

    优点:so easy。用java代码实现基本没什么难度。

    缺点:这效率让我心中奔过十万匹草泥马,而且匹配的是不是有些蛋疼,如果是英文时你会发现一个很无语的事情,比如英文

    a是敏感词,那我如果是一篇英文文档,那程序它妹的得处理多少次敏感词?谁能告诉我?

    ②传说中的DFA算法(有穷自动机),也正是我要给大家分享的,毕竟感觉比较通用,算法的原理希望大家能够自己去网上查查

    资料,这里就不详细说明了。

    优点:至少比上面那sb效率高点。

    缺点:对于学过算法的应该不难,对于没学过算法的用起来也不难,就是理解起来有点gg疼,匹配效率也不高,比较耗费内存,

    敏感词越多,内存占用的就越大。

    ③第三种在这里要特别说明一下,那就是你自己去写一个算法吧,或者在现有的算法的基础上去优化,这也是追求的至高境界之一。

    那么,传说中的DFA算法是怎么实现的呢?

    第一步:敏感词库初始化(将敏感词用DFA算法的原理封装到敏感词库中,敏感词库采用HashMap保存),代码如下:

    package com.cfwx.rox.web.sysmgr.util;

    import java.util.HashMap;

    import java.util.HashSet;

    import java.util.Iterator;

    import java.util.List;

    import java.util.Map;

    import java.util.Set;

    import com.cfwx.rox.web.common.model.entity.SensitiveWord;

    /**

    * 敏感词库初始化

    *

    * @author AlanLee

    *

    */

    public class SensitiveWordInit

    {

    /**

    * 敏感词库

    */

    public HashMap sensitiveWordMap;

    /**

    * 初始化敏感词

    *

    * @return

    */

    public Map initKeyWord(List sensitiveWords)

    {

    try

    {

    // 从敏感词集合对象中取出敏感词并封装到Set集合中

    Set keyWordSet = new HashSet();

    for (SensitiveWord s : sensitiveWords)

    {

    keyWordSet.add(s.getContent().trim());

    }

    // 将敏感词库加入到HashMap中

    addSensitiveWordToHashMap(keyWordSet);

    }

    catch (Exception e)

    {

    e.printStackTrace();

    }

    return sensitiveWordMap;

    }

    /**

    * 封装敏感词库

    *

    * @param keyWordSet

    */

    @SuppressWarnings("rawtypes")

    private void addSensitiveWordToHashMap(Set keyWordSet)

    {

    // 初始化HashMap对象并控制容器的大小

    sensitiveWordMap = new HashMap(keyWordSet.size());

    // 敏感词

    String key = null;

    // 用来按照相应的格式保存敏感词库数据

    Map nowMap = null;

    // 用来辅助构建敏感词库

    Map newWorMap = null;

    // 使用一个迭代器来循环敏感词集合

    Iterator iterator = keyWordSet.iterator();

    while (iterator.hasNext())

    {

    key = iterator.next();

    // 等于敏感词库,HashMap对象在内存中占用的是同一个地址,所以此nowMap对象的变化,sensitiveWordMap对象也会跟着改变

    nowMap = sensitiveWordMap;

    for (int i = 0; i < key.length(); i++)

    {

    // 截取敏感词当中的字,在敏感词库中字为HashMap对象的Key键值

    char keyChar = key.charAt(i);

    // 判断这个字是否存在于敏感词库中

    Object wordMap = nowMap.get(keyChar);

    if (wordMap != null)

    {

    nowMap = (Map) wordMap;

    }

    else

    {

    newWorMap = new HashMap();

    newWorMap.put("isEnd", "0");

    nowMap.put(keyChar, newWorMap);

    nowMap = newWorMap;

    }

    // 如果该字是当前敏感词的最后一个字,则标识为结尾字

    if (i == key.length() - 1)

    {

    nowMap.put("isEnd", "1");

    }

    System.out.println("封装敏感词库过程:"+sensitiveWordMap);

    }

    System.out.println("查看敏感词库数据:" + sensitiveWordMap);

    }

    }

    }

    第二步:写一个敏感词过滤工具类,里面可以写上自己需要的方法,代码如下:

    package com.cfwx.rox.web.sysmgr.util;

    import java.util.HashSet;

    import java.util.Iterator;

    import java.util.Map;

    import java.util.Set;

    /**

    * 敏感词过滤工具类

    *

    * @author AlanLee

    *

    */

    public class SensitivewordEngine

    {

    /**

    * 敏感词库

    */

    public static Map sensitiveWordMap = null;

    /**

    * 只过滤最小敏感词

    */

    public static int minMatchTYpe = 1;

    /**

    * 过滤所有敏感词

    */

    public static int maxMatchType = 2;

    /**

    * 敏感词库敏感词数量

    *

    * @return

    */

    public static int getWordSize()

    {

    if (SensitivewordEngine.sensitiveWordMap == null)

    {

    return 0;

    }

    return SensitivewordEngine.sensitiveWordMap.size();

    }

    /**

    * 是否包含敏感词

    *

    * @param txt

    * @param matchType

    * @return

    */

    public static boolean isContaintSensitiveWord(String txt, int matchType)

    {

    boolean flag = false;

    for (int i = 0; i < txt.length(); i++)

    {

    int matchFlag = checkSensitiveWord(txt, i, matchType);

    if (matchFlag > 0)

    {

    flag = true;

    }

    }

    return flag;

    }

    /**

    * 获取敏感词内容

    *

    * @param txt

    * @param matchType

    * @return 敏感词内容

    */

    public static Set getSensitiveWord(String txt, int matchType)

    {

    Set sensitiveWordList = new HashSet();

    for (int i = 0; i < txt.length(); i++)

    {

    int length = checkSensitiveWord(txt, i, matchType);

    if (length > 0)

    {

    // 将检测出的敏感词保存到集合中

    sensitiveWordList.add(txt.substring(i, i + length));

    i = i + length - 1;

    }

    }

    return sensitiveWordList;

    }

    /**

    * 替换敏感词

    *

    * @param txt

    * @param matchType

    * @param replaceChar

    * @return

    */

    public static String replaceSensitiveWord(String txt, int matchType, String replaceChar)

    {

    String resultTxt = txt;

    Set set = getSensitiveWord(txt, matchType);

    Iterator iterator = set.iterator();

    String word = null;

    String replaceString = null;

    while (iterator.hasNext())

    {

    word = iterator.next();

    replaceString = getReplaceChars(replaceChar, word.length());

    resultTxt = resultTxt.replaceAll(word, replaceString);

    }

    return resultTxt;

    }

    /**

    * 替换敏感词内容

    *

    * @param replaceChar

    * @param length

    * @return

    */

    private static String getReplaceChars(String replaceChar, int length)

    {

    String resultReplace = replaceChar;

    for (int i = 1; i < length; i++)

    {

    resultReplace += replaceChar;

    }

    return resultReplace;

    }

    /**

    * 检查敏感词数量

    *

    * @param txt

    * @param beginIndex

    * @param matchType

    * @return

    */

    public static int checkSensitiveWord(String txt, int beginIndex, int matchType)

    {

    boolean flag = false;

    // 记录敏感词数量

    int matchFlag = 0;

    char word = 0;

    Map nowMap = SensitivewordEngine.sensitiveWordMap;

    for (int i = beginIndex; i < txt.length(); i++)

    {

    word = txt.charAt(i);

    // 判断该字是否存在于敏感词库中

    nowMap = (Map) nowMap.get(word);

    if (nowMap != null)

    {

    matchFlag++;

    // 判断是否是敏感词的结尾字,如果是结尾字则判断是否继续检测

    if ("1".equals(nowMap.get("isEnd")))

    {

    flag = true;

    // 判断过滤类型,如果是小过滤则跳出循环,否则继续循环

    if (SensitivewordEngine.minMatchTYpe == matchType)

    {

    break;

    }

    }

    }

    else

    {

    break;

    }

    }

    if (!flag)

    {

    matchFlag = 0;

    }

    return matchFlag;

    }

    }

    第三步:一切都准备就绪,当然是查询好数据库当中的敏感词,并且开始过滤咯,代码如下:

    @SuppressWarnings("rawtypes")

    @Override

    public Set sensitiveWordFiltering(String text)

    {

    // 初始化敏感词库对象

    SensitiveWordInit sensitiveWordInit = new SensitiveWordInit();

    // 从数据库中获取敏感词对象集合(调用的方法来自Dao层,此方法是service层的实现类)

    List sensitiveWords = sensitiveWordDao.getSensitiveWordListAll();

    // 构建敏感词库

    Map sensitiveWordMap = sensitiveWordInit.initKeyWord(sensitiveWords);

    // 传入SensitivewordEngine类中的敏感词库

    SensitivewordEngine.sensitiveWordMap = sensitiveWordMap;

    // 得到敏感词有哪些,传入2表示获取所有敏感词

    Set set = SensitivewordEngine.getSensitiveWord(text, 2);

    return set;

    }

    最后一步:在Controller层写一个方法给前端请求,前端获取到需要的数据并进行相应的处理,代码如下:

    /**

    * 敏感词过滤

    *

    * @param text

    * @return

    */

    @RequestMapping(value = "/word/filter")

    @ResponseBody

    public RespVo sensitiveWordFiltering(String text)

    {

    RespVo respVo = new RespVo();

    try

    {

    Set set = sensitiveWordService.sensitiveWordFiltering(text);

    respVo.setResult(set);

    }

    catch (Exception e)

    {

    throw new RoxException("过滤敏感词出错,请联系维护人员");

    }

    return respVo;

    }

    总结

    以上就是这篇文章的全部内容了,代码中写了不少的注释,大家可以动动自己的脑筋好好的理解一下。希望本文的内容对大家的学习或者工作能带来一定的帮助,如果有疑问大家可以留言交流,谢谢大家对脚本之家的支持。

    展开全文
  • 针对众多国内外研究者在XML关键字查询领域所作出的创新性工作,该文以XML关键字查询处理系统为框架来组织现有工作,重点分析和比较了查询生成、语义定义、排序机制、查询算法及结果展示等5个关键技术点所涉及的代表性...
  • TF-IDF(term frequency–inverse document frequency)是一种用于资讯检索与资讯探勘的常用加权技术。TF-IDF是一种统计方法,用以评估一字词...TF-IDF加权的各种形式常被搜寻引擎应用,作为文件与用户查询之间相...
    TF-IDF(term frequency–inverse document frequency)是一种用于资讯检索与资讯探勘的常用加权技术。TF-IDF是一种统计方法,用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随著它在文件中出现的次数成正比增加,但同时会随著它在语料库中出现的频率成反比下降。TF-IDF加权的各种形式常被搜寻引擎应用,作为文件与用户查询之间相关 ...

    TF/IDF算法可能并不是百度的重要方法,google适用;百度个人认为是向量空间模型,实质也是TF/IDF。

    在招聘的时候,如果碰到信息专业的学生,我总是喜欢问,你知道信息论是谁提出来的吗?应聘的人没有一个能答出来,哎呀,信息论其实对于SEO非常重要,建议大家来看下,tf、idf看起来是比较简单的的一个 信息处理方法,但是想搞明白并且在实际工作中灵活适用,怕不是那么容易的事情了。--沙僧SEO.

    在今日我们可以从网络上吸收大量资讯,有时候一堆文章看不完。如果我们想要吸收资讯,时间却又不够的时候,使用电脑帮我们过滤资讯,或是用电脑帮我们做个总整理,是个方法。如果今天手中有一篇文章,我们想要用电脑帮我们找出这篇文章最重要的关键字,要怎麽做呢?在资讯检索 (IR: Information Retrieval)领域里面,有个基础的方法,入门必学的方法,就是使用 TF 和 IDF (TF: Term Frequency, IDF: Inverse Document Frequency)。使用这两个估计值,可以让电脑具有计算重要关键字的能力,进而节省我们的时间。

     

      接下来让我们看看,TF 和 IDF 个是甚麽东西呢?TF 全名是Term Frequency,也就是某个关键字出现的次数,譬如说某篇文章里面,「电脑」这个词出现很多次,或是「使用者需求」这个词出现很多次,那麽这些词句的出现频率,就会很高。一篇文章中出现很多次的词句,必定有其重要性。譬如说一篇论述「人工智慧」的文章,「人工智慧」这个词句再文章中出现的频率也一定很高。然而为甚麽除了 TF (Term Frequency) 以外,还要有 IDF (Inverse Document Frequency) 呢?

      让我们先想想,如果单使用某个字词出现的频率,来判断一篇文章最重要的关键字,会有甚麽困难。首先,我们会遇到一些常用字词,出现的频率也很高,会和重要字词出现的频率一样高,让电脑因此无法分辨出,哪些是常用字词,那些是重要字词。如果就英文来说,有个规则是语言学家 (linguist) 归纳出来的规则,叫做 Zipf’s Law。

      引述中文维基百科的一段介绍如下:

      从根本上讲, 齐夫定律 可以表述为, 在自然语言的 语素库 里, 一个单词出现的频率与它在频率表里的排名成 反比. 所以, 频率最高的单词出现的频率大约是出现频率第二位的单词的 2 倍,而出现频率第二位的单词则是出现频率第四位的单词的2倍。这个定律被作为任何与 power law probability distributions 有关的事物的参考。 这个 “定律” 是 Harvard linguist George Kingsley Zipf (IPA [z?f])发表的。

    比如, 在 Brown 语库, “the” 是最常见的单词,它在这个语库中出现了大约 7 %(10 万单词中出现 69971 次)。正如齐夫定律中所描述的一样,出现次数为第二位的单词 “of” 占了整个语库中的 3.5% (36411次), 之後的是”and” (28852次). 仅仅 135 但此项就占了 Brown 语库的一半。

      所以我们现在知道问题在哪边了。如果只用词句出现的频率来判断某一篇文章里面最重要的关键字,我们可能会找到常用字,而不是最重要的字,像是英文里面的 “the”、”a”、”it”,都是常常出现的字,但是通常一篇文章里面最重要的字不是这些字,即使那些重要的字出现的频率也很高。

      这个时候我们要怎麽办呢?IDF 在这个时候就帮上忙了。在了解 IDF 之前,我们先了解 DF 是甚麽。DF 就是Document Frequency,也就是说,如果今天我们手中有固定 N 篇文章,某个关键字的 Document Frquency (DF),就是说这个关键字在 N 篇文章里面出现了几次。Inverse Document Frequency (IDF) 则是把 DF 取倒数,如此一来,一个数字乘以 IDF,就等於是除以 DF 的意思。

      有了 TF 和 IDF 以後,我们就可以计算 TF 乘上 IDF,对每一个关键字都算出一个分数。这个分数的高低,就代表了这个关键字在某篇文章中的重要程度。为甚麽我们说这样子可以找出重要的字,而不是常出现的字呢?因为 TF 会把某篇文章中,出现最多次的排在第一位,其次的排在第二位,以此类推。然而乘上 IDF 以後,也就是除以 DF,那些常常出现的字,像是英文中的 “the”、”a”、”it”,因为每一篇文章都会出现,所以 DF 就大。DF 大,取倒数之後的 IDF 就小,IDF 小,乘上 TF 以後,虽然”the”、”a”、”it”在某篇文章中出现的频率很高,但是因为 IDF 小,TF * IDF 一相乘,重要性就变低了,我们 (电脑程式) 就不会把这些常出现的字,误认为是重要的字了!

      真正重要的字会得到甚麽样子的分数呢?如果这篇文章刚好在讲 AI,”AI” 出现很多次,因此 “AI” 在这篇文章里面的 TF 很高。然而我们电脑资料库里面的 N 篇文章,并不是每一篇都在讲 AI,也因此”AI”可能只有在 N 篇文章里面的某 3 篇文章出现,因此 DF 只有 3,IDF 变成 0.33,假设我们 N = 100 有 100 篇文章在资料库里面,其他常出现字像是 “the” 每一篇都出现,DF 就是 100,IDF 就是 0.01。所以 “AI” 的 IDF 会比 “the” 的 IDF 高,假设这篇文章中 “AI” 和 “the” 两个字出现的次数刚好一样,乘上 IDF 以後,”AI” 这个字的分数就比 “the” 这个字的分数来的高,电脑也就会判断 “AI” 是这篇文章重要的关键字,而 “the” 这个字并不是这篇文章的重要关键字。

      所以经由 TF * IDF,我们可以计算某个关键字,在某篇文章里面的重要性。从这一个方向,我们可以计算一篇文章中重点的字有哪些,帮我们做一篇文章的总整理。从相反的方向,我们可以给定关键字,然後再每一篇文章里面为这个关键字计算一次 TF * IDF,然後比较哪一篇文章,这个关键字是最具重要性的,用这个方法找出和一个关键字最相关的文章。不管是从文章找出重点字词,或是由关键字找相关文章,TF * IDF 都是个基本且不错的方法。会写程式又还没嚐试过这个方法的读者,或许可以亲自试试看,不过可能要先自己准备文章资料库 (corpus),或是从网际网路上面用网页撷取器 (crawler) 存几篇有兴趣的网页,然後把 HTML 标签清理乾净,剩下纯文字,就可以用这个方法来小试身手罗!

      我们也可以比较一下人类和电脑的不同。电脑做数学数字的计算,或是执行固定的步骤 ,非常擅长,速度也很快。人类可以了解一个字的意思,读完一篇文章以後,了解了意思,之後要找这篇文章最重要的关键字,是从「意义」开始,回忆出或做出结论,这篇文章重要的关键字是甚麽。
      然而如果要电脑也遵照这个方向,先了解字的意义,再了解文章的意义,然後在做出结论,这篇文章的重要关键字,反而困难,因为要了解字的意义,电脑需要先有一个语意网路 (Semantic Network),或是知识的分类关系树 (Ontology),把字句依照语意分门别类,有如生物里面的「界门纲目科属种」一般的关系分类,才有办法了解一个字和其他字的关系。之後要了解一篇文章,又必须要了解一个句子,牵涉到自然语言处理 (NLP: Natural language Processing) 的问题,像是从句子里面找出主词、动词、和受词,以及补语,分辨出子句和主句,代名词的指称,以及前後文判断产生不同的剖析 (parsing)。了解完一句,才能了解整篇文章。

      因此,TF * IDF 对於电脑来说,计算速度快,工程也不浩大,不用大型计算机就可以计算。这边也可以顺便提到 strong AI 和 weak AI 的关系。如果就工程的角度,TF * IDF 是个好方法,it works! 节省我们的时间,或是解决大问题中的一个小环节。然而 strong AI 在这边会提出「中文房间」(Chinese Room) 的论证,也就是说,电脑能够找出重要关键字,是否就代表电脑真的「知道」(understand) 关键字的意义呢?

      中文房间 (Chinese Room) 简单地说,就是一个人关在房间里面,只留两个窗口,一个地方会送纸条出来,另一个地方会送纸条出去。房间里面有一本手册,里面写满对照表,记载者看到甚麽英文字,就应该输出甚麽中文字,以及一些指令的对照,譬如说窗口送一个指令说 COMBINE,就把两个中文字写在一起才送出去。接着我们在外面就开始送英文句子进去这个房间,另一个窗口就会有这句话的中文翻译跑出来。然而这个论证想要坦讨的就是,虽然这个房间看起来像是会把英文翻译成中文,但是在房间里面的那个操作人员并不懂中文,他指是按照指令,还有手册里面的对照表,机械式地动作,可是外面看起来像是这个房间会英翻中,因此这个房间应该懂得中文才对。

      在这边我的看法是,也许就近程来看,我们只要有可以解决问题的解答就可以,不管电脑是否真的懂 (understand) 字的意义。然而长期来说,如果我们真的需要具有人类的智力的电脑出现,能够真的懂而不是行为上看起来懂,那麽就要仔细探讨中文房间这种论证。也许生物的方法,像是计算神经科学的方法,是一个方向。

      我们可能又会问,神经元只有动作电位和静止两个状态,怎麽能了解意义?但是只有一个神经元,或许没办法了解意义,全部大脑的神经元交互作用,意义可能就因此被了解了!其中的奥妙,就是计算神经科学嚐试要解答的问题之一。有兴趣的读者也可以一起从人脑开始,解决 strong AI 的问题。或是有数学的高手,也许某一个数学理论,可以很漂亮地解决意义了解的问题也说不定,像是 manifolds,具有一个集合使用不同面向来观看的特性,同时具有 Global 和 Local 的性质,是个不错的候选选项。从这个方向去解决 strong AI 也是另一个可能性。总之,继续努力研究就是了!

     

    转载于:https://www.cnblogs.com/a198720/p/3990838.html

    展开全文
  • 构建结果子树是XML关键字查询处理的核心问题,其中求解与每个子树根节点相关的关键字节点是影响结果子树构建效率的重要步骤。针对已有方法不能正确求解基于ELCA(exclusive lowest common ancestor)语义的相关关键字...
  • 针对带噪声数据的聚类问题,提出一种基于上下文约束的噪声模糊聚类算法。该算法基于标准的模糊C-均值聚类理论,在修改模糊聚类目标函数的同时,结合问题的实际背景引入上下文模糊集,修改模糊划分空间的约束条件,以...
  • balance用于定义负载均衡的算法,可用于defaults、listen和backend中。 balance使用方法如下: balance <algorithm> [ <arguments> ] balance url_param <param> [check_post [<max_wait>...
  • 提出了一种多关键字云资源搜索算法,在基于分层超级节点的云资源搜索算法基础上进行路由算法改进,希望实现多关键字的精确查询。对多关键字的生成、分割及存储作出了详细说明,提出一种有效的基于数据集的索引搜索...
  • 基于SLCA的结构关系,提出了一种推测多个关键字内在联系的XML关键字查询结果排序方法:通过LISA Ⅱ 算法获得SLCA;根据SLCA的结构信息推测出各个关键字之间的内在结构关系,得到所有关键字组成的关系树;然后根据关系树...
  • 最近百度公司好像是修改了指数查询算法,让很多网站都无法进行指数查询,比较站长站,爱站等 知名站长网站都无法查询。 在这里我使用Socket的方法来实现,也希望高手多多指点 分为这样几步,第一步是得到百度...
  • 短语匹配和广泛匹配修饰语以下是2019年7月31日谷歌官方广告公告原文:在未来几周内,广泛匹配修饰词和短语匹配关键字也将开始匹配搜索查询中与关键字具有相同含义的单词。每一种匹配类型都是不同的。让我们来看看每...
  • 目的是构建医疗领域的一个actree,在neo4j数据库中查询一些字符的前期处理。 这个时候再用find()感觉自己就不是算法工程师了,这太没有效率了,而且你会发现在同时处理几千个任务的时候,会出现cpu的瓶颈。 如果采用...
  • tf-idf算法,实现文章关键字抽取

    千次阅读 2014-01-21 15:04:44
    TF-IDF(term frequency–inverse document frequency)是一种用于资讯检索与资讯探勘的常用加权技术 TF-IDF是一种统计方法,用以评估一字词对于一个...TF-IDF加权的各种形式常被搜索引擎应用,作为文件与用户查询之间
  • 程序员常用查询算法

    2020-06-04 17:40:57
    说明: (2)、(3)、(4)本质上都是通过数组的中间值,将关键字(key)逐渐缩小查找范围,二分查找以数组中间值将查找范围缩小一半;插值查找也是通过某个中间值来缩小查找范围,但是中间值是动态变化的,根据插值...
  • 设计了n元属性组来描述云资源, 并为...仿真实验表明, 在云资源的属性发生变动时, 该算法在更新索引时在网络中产生的信息个数是一个常数n, 数目远远小于其他的多关键字区间查询算法, 查找资源时网络开销不仅小而且稳定。
  • 最全的查询算法详解

    2019-12-19 15:12:14
    查找算法 -- 简介 查找(Searching)就是根据给定的某个值,在查找表中确定一个其关键字等于给定值的数据元素。 查找表(Search Table):由同一类型的数据元素构成的集合 关键字(Key):数据元素中某个数据项的...
  • 为了弥补保序加密算法的隐私泄漏问题,结合对称可搜索加密技术基本思想,提出一种新型的具有隐私保护功能的范围数据加密查询算法。在该算法中,将数字范围转换为特殊关键字并放入布隆过滤器进行存储与命中判定,其中...
  • 执行查询算法基本概念: 三类查找方法:线性查找、树形查找、哈希表查找 动态查找表:在查找的同时,对表做修改操作(如插入和删除),则相应的表称为动态查找表 静态查找表:与动态查找表相反 查找过程中对关键字...
  • 在结构化P2P网络中,针对分布式散列表与复杂查询之间的矛盾,提出了一个在分布式散列表网络中基于多关键字的数据信息索引和查找算法,对该算法进行了分析和优化,为解决分布式散列表网络与复杂查询之间的矛盾提供了...
  • 新版本的产品已经上线,但是还没有一个...wand算法原本用于匹配文章是与查询关键词之间的匹配度,在这里把店铺和品牌当做文章,其中的商品特性当做文章中的内容,在必要的地方进行了修改,以更好的符合店铺搜索的需要。
  • n个学生的身高按从小到大的顺序存在一个一维数组中,若用户需要以身高值为关键字查询某学生的相关信息,请设计一个有效的算法。(初学算法不怎么会,麻烦回答的时候附上程序,c或者c++都行。我自己认为用二分查找,...
  • 我要模糊查询“1”关键字 我要把带“1”的全部查出来,如果是二级菜单要把一级顺便连出来, 如果是三级要把二级和一级全部查出来,如果只是一级,只显示一级菜单, 两个查询 1,全部查出来,放map中 (父id,对象) 2...
  • 分块查询算法(JAVA)

    千次阅读 2018-03-12 16:54:13
    分块查找要求把一个大的线性表分解成若干块,每块中的节点可以任意存放,但块与块之间必须排序步骤:step1 先选取各块中的最大关键字构成一个索引表;step2 查找分两个部分:先对索引表进行二分查找或顺序查找,以...
  • 分块查找 介于顺序查找与折半查找之间。...4.在块内顺序查询关键字。 #include<stdio.h> typedef struct node { int start; //定义每个数据块的头,尾及最大 int key; int tail; }Key; BlockSearch(int a
  • super()关键字

    2018-12-29 01:07:25
    super实现原理:通过c3算法,生成mro(method resolution order)列表,根据列表中元素顺序查询调用 super()不是指父类 而是指以实例化对象为起点的mro序列中的下一个   简洁点的三个原则就是: 子类在父类前,所有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 537
精华内容 214
关键字:

关键字查询算法