精华内容
下载资源
问答
  • 算法说明 这是一种利用动态规划思想实现的算法,也即是在运算过程中每一次计算都求出一个值,然后将这... 据说科学家DNA相似度的检测都是用这种算法 算法解析 以两个字符串为例,他们分别是“H ELLO”和“HALHELLO”

    算法说明

    这是一种利用动态规划思想实现的算法,也即是在运算过程中每一次计算都求出一个值,然后将这个值和前面计算的值比较,如果这个值比前面的值更加接近我们需要的结果则存储这个值,否则存储前面计算的值,这样在算法最后我就能得到最优结果。

    算法优点

    运算效率高
    据说科学家DNA相似度的检测都是用这种算法

    算法解析

    以两个字符串为例,他们分别是“H ELLO”和“HALHELLO”
    首先把他们分布在表格两边
    这里写图片描述
    然后开始匹配表格中每一个格子他们对应的字母是否相等
    如果相等:那么这个表格里就填一个他们左上角格子数字+1的数字,在这里我们把这个数字叫做”权值“。
    如果不相等:我们就比较这个格子的上方和左的方格子的权值大小,谁的数字大当前这个格子就填哪个权值。
    最后得到下表,我们可以明确的看到在最右下角权值是最大的,这个权值也就是两个字符串的最大权值(这个权值越大说明两个字符串的相似度越高)。
    这里写图片描述
    如果是列的数量大于行的数量的另外一种情况呢,最大的权值还会不会在最右下角?
    答案是:YES
    如下图所示
    这里写图片描述

    实现代码

    以下是一个匹配字符串相似度的算法。
    采用C++编写

    #include<iostream>
    #include<string>
    using namespace std;
    int main() {
        string src1, src2;
        src1 = "HELLO";
        src2 = "HALHELLO";
        //cin>>src1>>src2;
        //先动态申请一个二维数组用来存储权值
        int **grid = new int*[src1.length()+1]; //多申请一行(防止访问越界)
        for (size_t i = 0; i < src1.length()+1;i++) {
            grid[i] = new int[src2.length()+1];
        }
        //为了不影响正确的权值把多申请一行一列的权值赋值为0
        for (size_t i = 0; i < src1.length()+1;i++) {
            grid[i][0] = 0;
        }
        for (size_t i = 0; i < src2.length()+1; i++) {
            grid[0][i] = 0;
        }
        //开始计算权值
        for (size_t i = 1; i < src1.length()+1; i++)
        {
            for (size_t j = 1;  j < src2.length()+1;  j++)
            {
                //因为多申请了一行一列所以字符串要-1,否则访问越界
                if (src1.at(i-1) == src2.at(j-1)) {
                    //相同时,取左上角的权值+1
                    grid[i][j] = grid[i - 1][j - 1] + 1;
                }
                else {
                    //当不相同时,上边和左边的权值谁大就取谁
                    if (grid[i-1][j] > grid[i][j-1]) 
                    {
                        grid[i][j] = grid[i - 1][j];
                    }
                    else {
                        grid[i][j] = grid[i][j-1];
                    }
                }
            }
        }
        //因为我们在申请内存的时候多申请了一行,所以length不用减1
        cout << "两个字符串的最大权值为:" << grid[src1.length()][src2.length()] << endl;
        return 0;
    }

    运行结果

    两个字符串的最大权值为:5
    展开全文
  • 在处理数据时,有时需要找出数据中存在错误的数据或者对数据进行去重。对数据去重,如果存储在数据库中,我想一个sql就可以搞定,可是要找出数据中错误的数据,就比较困难,一般只能人工判断。举例:比如有一批账单...

    在处理数据时,有时需要找出数据中存在错误的数据或者对数据进行去重。对数据去重,如果存储在数据库中,我想一个sql就可以搞定,可是要找出数据中错误的数据,就比较困难,一般只能人工判断。举例:比如有一批账单中,存储的都是企业的名称,但想统计一下具体真正的有多少企业,我们可能会说,如果是数据库中,直接distinct一下不就出来了?对,我们可以使用distinct把重复的企业去掉,但是看看留下的企业名称是什么样子,“XXX科技股份有限公司”,'XXX科技股有限公司”,只要名称是人工手工输入的就不免会出错,前面的两个名称用sql统计肯定会认为是两家公司,可用人眼一看就知道,这两个是一家企业。那么,如果出现这种情况,怎样让计算机帮助我们找出这些出错的企业名称呢?

    在这里向您推荐一个Levenshtein算法,通过此算法,可以算出两个文本之间的一个阈值,我们简单称它为相似度。现在假设数据库中存在一个企业名称表,里面的名称都是手工输入的,我们可以通过此算法,计算出企业名称两两比较的相似度。一般我们把这个阈值设置到0.8以上时,几乎能够找出所有的人工手工输入的错误。在实际应用中,我们可以将这个阈值存入数据库中,在阈值中筛选一个合适的阈值,就能把相似的名称都找出。

    下面是一个Java代码示例:

    /**
     * <p>
     * <p>Title:DeleteRepeatData.java</p >
     * <p>Description: 用于两个字段查重</p >
     * <p>Date:2020/1/10 10:51</p >
     *
     * @version 1.0
     */
    public class DeleteRepeatData {
    
        public static float levenshtein(String str1, String str2) {
            //计算两个字符串的长度。
            int len1 = str1.length();
            int len2 = str2.length();
            //建立上面说的数组,比字符长度大一个空间
            int[][]dif = new int[len1 + 1][ len2 + 1];
            //赋初值,步骤B。
            for (int a = 0; a <= len1; a++) {
                dif[a][0] =a;
            }
            for (int a = 0; a <= len2; a++) {
                dif[0][a] =a;
            }
            //计算两个字符是否一样,计算左上的值
            char [] ch1 = str1.toCharArray();
            char [] ch2 = str2.toCharArray();
            int temp;
            for (int i = 1; i <= len1; i++) {
                for (int j = 1; j <= len2; j++) {
                    if (ch1[i - 1] == ch2[j - 1]) {
                        temp = 0;
                    } else {
                        temp = 1;
                    }
                    //取三个值中最小的
                    int temp1 = dif[i - 1][j - 1]+temp;
                    int temp2 = dif[i][j - 1]+1;
                    int temp3 = dif[i - 1][j]+1;
                    int arr [] =  new int[]{temp1,temp2, temp3};
    
                    dif[i][j] =min(arr);
                }
            }
            //计算相似度
            float similarity = 1 - (float) dif[len1][len2] /Math.max(str1.length(), str2.length());
            return similarity;
        }
    
        //得到最小值
        private static int min(int[]arr) {
            int min = arr[0];
            for( int i :arr){
                if (min > i) {
                    min = i;
                }
            }
            return min;
        }
    }
    
    

    调用实例:

    public static void main(String[] args) {
            String str = "这是第一行内容";
            String str2 = "这是第二行内容";
            System.out.println("相似度是:"+DeleteRepeatData.levenshtein(str,str2));
    }

    展开全文
  • 中文相似度匹配算法

    千次阅读 2017-12-18 22:12:38
    经典算法1---相似度--模糊查询,查抄袭,语言识别 转载 2016年07月11日 21:57:53 标签: 经典算法 / java / 8878 编辑 删除 from http://wdhdmx.iteye.com/blog/1343856#bc2319361 1.百度百科介绍: ...

    经典算法1---相似度--模糊查询,查抄袭,语言识别


    1.百度百科介绍:

    Levenshtein 距离,又称编辑距离,指的是两个字符串之间,由一个转换成另一个所需的最少编辑操作次数。

    许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符。

    编辑距离的算法是首先由俄国科学家Levenshtein提出的,故又叫Levenshtein Distance。

    2.用途

    模糊查询

    3.实现过程

    a.首先是有两个字符串,这里写一个简单的 abc和abe

    b.将字符串想象成下面的结构。

    A处 是一个标记,为了方便讲解,不是这个表的内容。

     

      abc a b c
    abe 0 1 2 3
    a 1 A处    
    b 2      
    e 3      

    c.来计算A处 出得值

    它的值取决于:左边的1、上边的1、左上角的0.

    按照Levenshtein distance的意思:

    上面的值和左面的值都要求加1,这样得到1+1=2。

    A处 由于是两个a相同,左上角的值加0.这样得到0+0=0。

    这是后有三个值,左边的计算后为2,上边的计算后为2,左上角的计算为0,所以A处 取他们里面最小的0.

    d.于是表成为下面的样子

      abc a b c
    abe 0 1 2 3
    a 1 0    
    b 2 B处    
    e 3      

    B处 会同样得到三个值,左边计算后为3,上边计算后为1,在B处 由于对应的字符为a、b,不相等,所以左上角应该在当前值的基础上加1,这样得到1+1=2,在(3,1,2)中选出最小的为B处的值。

    e.于是表就更新了

     

      abc a b c
    abe 0 1 2 3
    a 1 0    
    b 2 1    
    e 3 C处    

    C处 计算后:上面的值为2,左边的值为4,左上角的:a和e不相同,所以加1,即2+1,左上角的为3。

    在(2,4,3)中取最小的为C处 的值。

    f.于是依次推得到

        a b c
      0 1 2 3
    a 1 A处 0 D处 1 G处 2
    b 2 B处 1 E处 0 H处 1
    e 3 C处 2 F处 1 I处 1

     

    I处: 表示abc 和abe 有1个需要编辑的操作。这个是需要计算出来的。

    同时,也获得一些额外的信息。

    A处: 表示a      和a      需要有0个操作。字符串一样

    B处: 表示ab    和a      需要有1个操作。

    C处: 表示abe  和a      需要有2个操作。

    D处: 表示a      和ab    需要有1个操作。

    E处: 表示ab    和ab    需要有0个操作。字符串一样

    F处: 表示abe  和ab    需要有1个操作。

    G处: 表示a      和abc   需要有2个操作。

    H处: 表示ab    和abc    需要有1个操作。

    I处: 表示abe   和abc    需要有1个操作。

    g.计算相似度

    先取两个字符串长度的最大值maxLen,用1-(需要操作数除maxLen),得到相似度。

    例如abc 和abe 一个操作,长度为3,所以相似度为1-1/3=0.666。

    4.代码实现

    直接能运行, 复制过去就行。

    1. package code;    
    2.     
    3. /**  
    4.  * @className:MyLevenshtein.java  
    5.  * @classDescription:Levenshtein Distance 算法实现  
    6.  * 可以使用的地方:DNA分析   拼字检查   语音辨识   抄袭侦测  
    7.  * @author:donghai.wan  
    8.  * @createTime:2012-1-12  
    9.  */    
    10. public class MyLevenshtein {    
    11.     
    12.     public static void main(String[] args) {    
    13.         //要比较的两个字符串    
    14.         String str1 = "今天星期四";    
    15.         String str2 = "今天是星期五";    
    16.         levenshtein(str1,str2);    
    17.     }    
    18.     
    19.     /**  
    20.      *   DNA分析   拼字检查   语音辨识   抄袭侦测  
    21.      *   
    22.      * @createTime 2012-1-12  
    23.      */    
    24.     public static void levenshtein(String str1,String str2) {    
    25.         //计算两个字符串的长度。    
    26.         int len1 = str1.length();    
    27.         int len2 = str2.length();    
    28.         //建立上面说的数组,比字符长度大一个空间    
    29.         int[][] dif = new int[len1 + 1][len2 + 1];    
    30.         //赋初值,步骤B。    
    31.         for (int a = 0; a <= len1; a++) {    
    32.             dif[a][0] = a;    
    33.         }    
    34.         for (int a = 0; a <= len2; a++) {    
    35.             dif[0][a] = a;    
    36.         }    
    37.         //计算两个字符是否一样,计算左上的值    
    38.         int temp;    
    39.         for (int i = 1; i <= len1; i++) {    
    40.             for (int j = 1; j <= len2; j++) {    
    41.                 if (str1.charAt(i - 1) == str2.charAt(j - 1)) {    
    42.                     temp = 0;    
    43.                 } else {    
    44.                     temp = 1;    
    45.                 }    
    46.                 //取三个值中最小的    
    47.                 dif[i][j] = min(dif[i - 1][j - 1] + temp, dif[i][j - 1] + 1,    
    48.                         dif[i - 1][j] + 1);    
    49.             }    
    50.         }    
    51.         System.out.println("字符串\""+str1+"\"与\""+str2+"\"的比较");    
    52.         //取数组右下角的值,同样不同位置代表不同字符串的比较    
    53.         System.out.println("差异步骤:"+dif[len1][len2]);    
    54.         //计算相似度    
    55.         float similarity =1 - (float) dif[len1][len2] / Math.max(str1.length(), str2.length());    
    56.         System.out.println("相似度:"+similarity);    
    57.     }    
    58.     
    59.     //得到最小值    
    60.     private static int min(int... is) {    
    61.         int min = Integer.MAX_VALUE;    
    62.         for (int i : is) {    
    63.             if (min > i) {    
    64.                 min = i;    
    65.             }    
    66.         }    
    67.         return min;    
    68.     }    
    69.     
    70. }    
    package code;  
      
    /** 
     * @className:MyLevenshtein.java 
     * @classDescription:Levenshtein Distance 算法实现 
     * 可以使用的地方:DNA分析   拼字检查   语音辨识   抄袭侦测 
     * @author:donghai.wan 
     * @createTime:2012-1-12 
     */  
    public class MyLevenshtein {  
      
        public static void main(String[] args) {  
            //要比较的两个字符串  
            String str1 = "今天星期四";  
            String str2 = "今天是星期五";  
            levenshtein(str1,str2);  
        }  
      
        /** 
         *   DNA分析   拼字检查   语音辨识   抄袭侦测 
         *  
         * @createTime 2012-1-12 
         */  
        public static void levenshtein(String str1,String str2) {  
            //计算两个字符串的长度。  
            int len1 = str1.length();  
            int len2 = str2.length();  
            //建立上面说的数组,比字符长度大一个空间  
            int[][] dif = new int[len1 + 1][len2 + 1];  
            //赋初值,步骤B。  
            for (int a = 0; a <= len1; a++) {  
                dif[a][0] = a;  
            }  
            for (int a = 0; a <= len2; a++) {  
                dif[0][a] = a;  
            }  
            //计算两个字符是否一样,计算左上的值  
            int temp;  
            for (int i = 1; i <= len1; i++) {  
                for (int j = 1; j <= len2; j++) {  
                    if (str1.charAt(i - 1) == str2.charAt(j - 1)) {  
                        temp = 0;  
                    } else {  
                        temp = 1;  
                    }  
                    //取三个值中最小的  
                    dif[i][j] = min(dif[i - 1][j - 1] + temp, dif[i][j - 1] + 1,  
                            dif[i - 1][j] + 1);  
                }  
            }  
            System.out.println("字符串\""+str1+"\"与\""+str2+"\"的比较");  
            //取数组右下角的值,同样不同位置代表不同字符串的比较  
            System.out.println("差异步骤:"+dif[len1][len2]);  
            //计算相似度  
            float similarity =1 - (float) dif[len1][len2] / Math.max(str1.length(), str2.length());  
            System.out.println("相似度:"+similarity);  
        }  
      
        //得到最小值  
        private static int min(int... is) {  
            int min = Integer.MAX_VALUE;  
            for (int i : is) {  
                if (min > i) {  
                    min = i;  
                }  
            }  
            return min;  
        }  
      
    }  


    5.猜测原理

    from   http://www.lanceyan.com/tech/arch/simhash_hamming_distance_similarity.html

    通过 采集系统 我们采集了大量文本数据,但是文本中有很多重复数据影响我们对于结果的分析。分析前我们需要对这些数据去除重复,如何选择和设计文本的去重算法?常见的有余弦夹角算法、欧式距离、Jaccard相似度、最长公共子串、编辑距离等。这些算法对于待比较的文本数据不多时还比较好用,如果我们的爬虫每天采集的数据以千万计算,我们如何对于这些海量千万级的数据进行高效的合并去重。最简单的做法是拿着待比较的文本和数据库中所有的文本比较一遍如果是重复的数据就标示为重复。看起来很简单,我们来做个测试,就拿最简单的两个数据使用Apache提供的 Levenshtein for 循环100w次计算这两个数据的相似度。代码结果如下:

                 String s1  =  "你妈妈喊你回家吃饭哦,回家罗回家罗"  ;
                 String s2  =  "你妈妈叫你回家吃饭啦,回家罗回家罗"  ;

                 long t1  =  System. currentTimeMillis ( ) ;

                 for  ( int i  =  0 ; i  <  1000000 ; i ++ )  {
                        int dis  = StringUtils . getLevenshteinDistance (s1, s2 ) ;
                 }

                 long t2  =  System. currentTimeMillis ( ) ;

                 Systemout . println ( " 耗费时间: "  +  (t2  - t1 )  +  "  ms " ) ;

    耗费时间: 4266 ms

    大跌眼镜,居然计算耗费4秒。假设我们一天需要比较100w次,光是比较100w次的数据是否重复就需要4s,就算4s一个文档,单线程一分钟才处理15个文档,一个小时才900个,一天也才21600个文档,这个数字和一天100w相差甚远,需要多少机器和资源才能解决。

    为此我们需要一种应对于海量数据场景的去重方案,经过研究发现有种叫 local sensitive hash 局部敏感哈希 的东西,据说这玩意可以把文档降维到hash数字,数字两两计算运算量要小很多。查找很多文档后看到google对于网页去重使用的是simhash,他们每天需要处理的文档在亿级别,大大超过了我们现在文档的水平。既然老大哥也有类似的应用,我们也赶紧尝试下。simhash是由 Charikar 在2002年提出来的,参考 《Similarity estimation techniques from rounding algorithms》 。 介绍下这个算法主要原理,为了便于理解尽量不使用数学公式,分为这几步:

    • 1、分词,把需要判断文本分词形成这个文章的特征单词。最后形成去掉噪音词的单词序列并为每个词加上权重,我们假设权重分为5个级别(1~5)。比如:“ 美国“51区”雇员称内部有9架飞碟,曾看见灰色外星人 ” ==> 分词后为 “ 美国(4) 51区(5) 雇员(3) 称(1) 内部(2) 有(1) 9架(3) 飞碟(5) 曾(1) 看见(3) 灰色(4) 外星人(5)”,括号里是代表单词在整个句子里重要程度,数字越大越重要。

    • 2、hash,通过hash算法把每个词变成hash值,比如“美国”通过hash算法计算为 100101,“51区”通过hash算法计算为 101011。这样我们的字符串就变成了一串串数字,还记得文章开头说过的吗,要把文章变为数字计算才能提高相似度计算性能,现在是降维过程进行时。

    • 3、加权,通过 2步骤的hash生成结果,需要按照单词的权重形成加权数字串,比如“美国”的hash值为“100101”,通过加权计算为“4 -4 -4 4 -4 4”;“51区”的hash值为“101011”,通过加权计算为 “ 5 -5 5 -5 5 5”。

    • 4、合并,把上面各个单词算出来的序列值累加,变成只有一个序列串。比如 “美国”的 “4 -4 -4 4 -4 4”,“51区”的 “ 5 -5 5 -5 5 5”, 把每一位进行累加, “4+5 -4+-5 -4+5 4+-5 -4+5 4+5” ==》 “9 -9 1 -1 1 9”。这里作为示例只算了两个单词的,真实计算需要把所有单词的序列串累加。

    • 5、降维,把4步算出来的 “9 -9 1 -1 1 9” 变成 0 1 串,形成我们最终的simhash签名。 如果每一位大于0 记为 1,小于0 记为 0。最后算出结果为:“1 0 1 0 1 1”。

    整个过程图为:

    simhash计算过程图

    大家可能会有疑问,经过这么多步骤搞这么麻烦,不就是为了得到个 0 1 字符串吗?我直接把这个文本作为字符串输入,用hash函数生成 0 1 值更简单。其实不是这样的,传统hash函数解决的是生成唯一值,比如 md5、hashmap等。md5是用于生成唯一签名串,只要稍微多加一个字符md5的两个数字看起来相差甚远;hashmap也是用于键值对查找,便于快速插入和查找的数据结构。不过我们主要解决的是文本相似度计算,要比较的是两个文章是否相识,当然我们降维生成了hashcode也是用于这个目的。看到这里估计大家就明白了,我们使用的simhash就算把文章中的字符串变成 01 串也还是可以用于计算相似度的,而传统的hashcode却不行。我们可以来做个测试,两个相差只有一个字符的文本串,“你妈妈喊你回家吃饭哦,回家罗回家罗” 和 “你妈妈叫你回家吃饭啦,回家罗回家罗”。

    通过simhash计算结果为:

    1000010010101101111111100000101011010001001111100001001011001011

    1000010010101101011111100000101011010001001111100001101010001011

    通过 hashcode计算为:

    1111111111111111111111111111111110001000001100110100111011011110

    1010010001111111110010110011101

    大家可以看得出来,相似的文本只有部分 01 串变化了,而普通的hashcode却不能做到,这个就是局部敏感哈希的魅力。目前Broder提出的shingling算法和Charikar的simhash算法应该算是业界公认比较好的算法。在simhash的发明人Charikar的论文中并没有给出具体的simhash算法和证明,“量子图灵”得出的证明simhash是由随机超平面hash算法演变而来的

    现在通过这样的转换,我们把库里的文本都转换为simhash 代码,并转换为long类型存储,空间大大减少。现在我们虽然解决了空间,但是如何计算两个simhash的相似度呢?难道是比较两个simhash的01有多少个不同吗?对的,其实也就是这样,我们通过海明距离(Hamming distance)就可以计算出两个simhash到底相似不相似。两个simhash对应二进制(01串)取值不同的数量称为这两个simhash的海明距离。举例如下: 10101 和 00110 从第一位开始依次有第一位、第四、第五位不同,则海明距离为3。对于二进制字符串的a和b,海明距离为等于在a XOR b运算结果中1的个数(普遍算法)。

    为了高效比较,我们预先加载了库里存在文本并转换为simhash code 存储在内存空间。来一条文本先转换为 simhash code,然后和内存里的simhash code 进行比较,测试100w次计算在100ms。速度大大提升。

    未完待续:

    1、目前速度提升了但是数据是不断增量的,如果未来数据发展到一个小时100w,按现在一次100ms,一个线程处理一秒钟 10次,一分钟 60 * 10 次,一个小时 60*10 *60 次 = 36000次,一天 60*10*60*24 = 864000次。 我们目标是一天100w次,通过增加两个线程就可以完成。但是如果要一个小时100w次呢?则需要增加30个线程和相应的硬件资源保证速度能够达到,这样成本也上去了。能否有更好的办法,提高我们比较的效率?

    2、通过大量测试,simhash用于比较大文本,比如500字以上效果都还蛮好,距离小于3的基本都是相似,误判率也比较低。但是如果我们处理的是微博信息,最多也就140个字,使用simhash的效果并不那么理想。看如下图,在距离为3时是一个比较折中的点,在距离为10时效果已经很差了,不过我们测试短文本很多看起来相似的距离确实为10。如果使用距离为3,短文本大量重复信息不会被过滤,如果使用距离为10,长文本的错误率也非常高,如何解决?

    simhash_hammingdistance

    另:相似度方法综述!!!
    from http://blog.csdn.net/wangzhiqing3/article/details/8293286

    展开全文
  • 光谱匹配算法的研究与开发,蔡燕,,高光谱图像最显著的特征就是谱像合一。高光谱遥感图像数据包含了丰富的空间和光谱信息使得其分析处理集中于光谱维上进行图像信息
  • 基于聚类算法的路口相似度匹配算法的优化与实现.pdf
  • 标签别名语义相似度匹配算法: # -*- encoding=utf-8 -*- import pandas as pd import numpy as np import time time1=time.time() #定义一个标签有别名的合并函数 def combine_tag_name_alis(data1,data2): ...

    标签别名语义相似度匹配算法:
    这里写图片描述

    # -*- encoding=utf-8 -*-
    
    import pandas as pd
    import numpy as np
    import time
    time1=time.time()
    
    
    #定义一个标签有别名的合并函数
    def combine_tag_name_alis(data1,data2):
        """
        :param data1: 别名集
        :param data2:标签集
        :return: 合并后的结果集
        """
        # 筛选数据,找到有别名的标签
        data3 = data1[data1['alias'].isin(data2['key'])]
        data4=data2[~data2['key'].isin(data3['alias'])]
    
        #语义相似标签去重
        name1= list(set(data3['name']))
        name2=list(set(data4['key']))
        name3=name1+name2
        name4=list(set(name3))
    
    
        return name4
    
    
    if __name__ == '__main__':
    
        #  读取别名数据集
        data1 = pd.read_excel('C:/Users/xiaohu/Desktop/文本挖掘/标签语义相近发现合并算法/data/kktribe_tag_1.xlsx')
    
        #  读取标签数据集
        data2=pd.DataFrame({'key':['詹皇','小皇帝','内马尔','世界杯','姆巴佩','詹姆斯','姆巴佩','里奥·梅西','梅西','Lionel Andrés Messi','小老虎','凯文-杜兰特','凯文·杜兰特']})
    
        #  合并之后的标签集
        name=combine_tag_name_alis(data1,data2)
        print(name)
    
    
    
        time2 = time.time()
        print('总共耗时:' + str(time2 - time1) + 's')
    ['梅西', '沃尔科特', '姆巴佩', '詹姆斯', '内马尔', '杜兰特', '世界杯']
    总共耗时:0.07813286781311035s
    
    Process finished with exit code 0
    展开全文
  • 为解决本体异构、实现不同本体应用程序间互操作以及数据集成,提出一种基于RDF图的改进相似度传播匹配算法。首先通过WordNet发现初始相似对种子,经过预处理把本体表示成RDF三元组形式,针对RDF图的特点,将相似度传播的...
  • 计算文本相似度的常用算法

    千次阅读 2021-03-07 14:33:43
    NLP、数据挖掘领域中,文本分析是一个很重要的领域,这有助于我们去让...文本不仅仅是文字,文本相似度的应用更广,除了文字的匹配,还可以是图片、音频等,因为它们的实质都是在计算机中都是以二进制的方式存在的。相.
  •  /// 计算字符串相似度  ///  /// <param name="str1"></param>  /// <param name="str2"></param>  /// <returns></returns>  public decimal LevenshteinDistancePercent(string str1, string str2) ...
  • 常见的距离算法相似度(相关系数)计算方法 总结摘要 1.常见的距离算法 1.1欧几里得距离(Euclidean Distance) 根据两用户之间共同评价的Item为维度,建立一个多维的空间,那么通过用户对单一维度上的评价Score...
  • 针对不等长序列数据的关联问题, 提出基于滑动窗口的最优匹配增权法不等长序列相似度度量算法. 以较短序列作为滑动窗口遍历较长序列得到一组滑动相似度, 利用这组相似度形成最优权重, 加权得到不等长序列的相似度, 并...
  • 【python 以图搜图】三种图片相似度计算融合算法

    万次阅读 多人点赞 2019-02-19 11:49:34
    1、分别自定义三种计算图片相似度算法,计算图片相似度算法ORB算法,以及局部敏感哈希phash算法,还有传统的直方图计算相似度算法。 2、定义融合相似度阈值为0.85,若三种算法计算出来的相似度最大值大于等于0.85,...
  • 最近在做一个虚拟客服的项目,简单的了解了一下中文语境的集中句子相似度算法 看了大佬的项目和博客,不明觉厉,链接送上:https://github.com/wenyangchou/SimilarCharactor SimilarCharactor 基于音形码,...
  • NLP——计算文本相似度的常用算法

    千次阅读 2020-07-03 16:12:51
    文章目录一、绪论二、余弦相似度2.1 余弦相似度定义2.2 计算相似度步骤2.3 举例2.4 改进方式2.5 代码三、TF-IDF计算3.1 TF、IDE、TF-IDF的计算方法3.1.1 词频TF的计算方法3.1.2 反文档频率IDF的计算方法3.1.3 TF-IDF...
  • 图像处理之积分图应用三(基于NCC快速相似度匹配算法)基于Normalized cross correlation(NCC)用来比较两幅图像的相似程度已经是一个常见的图像处理手段。在工业生产环节检测、监控领域对对象检测与识别均有应用。...
  • } 新闻分类的步骤: 建立词典 词频统计(如果是中文,数据得先经过中文分词) 计算余弦相似性 根据相似度做判断,余弦相似度,值越大(越接近 111)就表示越相似。 原理就是这样,现在把这个项目完整的写出来: // ...
  • opencv 简单的图片相似度匹配

    千次阅读 2020-08-06 19:26:51
    1、各种图片读取的函数读取到的数据格式是 RGB 还是 BGR? 使用 scipy.misc.imread 读取的图片数据是 RGB 格式; 使用 cv2.imread 读取的图片数据是 BGR 格式; 使用 PIL.Image.open 读取的图片数据是RGB格式;...
  • python实现文本检索-文本相似度算法

    千次阅读 2019-12-27 10:19:28
    目的 给定一个或多个搜索词,如“高血压 患者”,从已有的若干篇文本中找出最相关的(n篇)文本。 理论知识 ... 1、基于word2vec的词语相似度计算模型 2、python的实现用到了gensim库 3...
  • 最近接到一个需求,需求直接来源于... -- 名称相似度超过一定比例的两个商品可以算成一个或者一组商品,用来后续组合处理2、什么样的数据才算是相似的? -- 两个名称相似度超过70%,算是描述的同一种商品3、怎么实现...
  • 文本相似度算法的对比及python实现

    千次阅读 多人点赞 2019-11-01 15:00:42
    文本相似度算法的对比及python实现 前言 通常我们有这样的需求:对两篇文章或者产品内容进行重复率查询。 为了解决类似的问题,罗列了一些常见的相似度算法,用python代码实现。 五种常见的相似度算法:余弦相似度...
  • 1、需求描述:数据库采集sql语句的记录表,包含记录编号-ID、日期时间-data、sql语句-statement,对表内每一条记录的sql语句和表内其他记录的sql语句进行模糊匹配,以顺序字符匹配方式进行,达到定义的相似度,就为...
  • 该模型将离散评分模糊化为梯形模糊数,考虑了评分模糊性和信息量,通过梯形模糊数来计算用户相似度,据此设计了协同过滤算法,并证明了该算法是传统协同过滤算法在模糊域的扩展。实验表明,该算法数据稀疏且用户数...
  • 一个简单的课设,详情见博客
  • 目录:序列相似度度量算法

    千次阅读 2019-07-20 15:32:49
    1.在本实例中,如果想将代码直接运行需注意以下几点: Python版本3.X(本人使用的是Python 3.6)...GitHub的数据及代码下载地址为:GitHub的数据及代码下载链接(如果从GitHub下载代码,麻烦给小Demo一个Star,您的...
  • 短文本相似度,即求解两个短文本之间的相似程度;它是文本匹配任务或文本蕴含任务的一种特殊形式,返回文本之间相似程度的具体数值。然而在工业界中,短文本相似度计算...目前,短文本相似度算法可以分为三大类:(1
  • 【机器学习】几种相似度算法分析

    万次阅读 多人点赞 2018-06-19 12:54:57
    最近开始研究推荐系统,其中常见的相似度算法有以下几种:1. 欧几里得距离欧几里得度量(euclidean metric)(也称欧氏距离)是一个通常采用的距离定义,指在m维空间中两个点之间的真实距离,或者向量的自然长度(即...
  • 图片相似度算法比较一般流程

    千次阅读 2019-08-25 22:39:24
    1、 缩放图片  将需要处理的图片所放到指定尺寸,缩放后图片大小由图片的信息量和复杂度决定。... 通常对比图像相似度和颜色关系不是很大,所以处理为灰度图,减少后期计算的复杂度。如果有特殊...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,454
精华内容 8,181
关键字:

数据相似度匹配算法