精华内容
下载资源
问答
  • 相似性

    千次阅读 2018-05-04 15:21:38
    拓扑相似性语义相似性(semantic similarity)定义在一组文档上或者术语上的度量,他们之间的距离基于他们的意义或者语义内容的相似性,而不是语法表示上的相似性。我们可以通过定义拓扑相似性来估计语义相似性。...

    拓扑相似性


    语义相似性(semantic similarity)定义在一组文档上或者术语上的度量,他们之间的距离基于他们的意义或者语义内容的相似性,而不是语法表示上的相似性。我们可以通过定义拓扑相似性来估计语义相似性。

    生物医学上的应用:它们主要用于比较基因和蛋白质的功能相似性,而不是它们的序列相似性,但它们也正在扩展到其他生物实体,如化合物,解剖实体和疾病等方面。

    常用来计算相似性:

    1.jaccard 相似性:Jaccard指数也称为交集交汇点和Jaccard相似系数(Paul Jaccard最初创造的系数),是用于比较样本集的相似性和多样性的统计量。 Jaccard系数测量有限样本集之间的相似性,并将其定义为交点的大小除以样本集的并集大小:如果AB都是空集的话,也定义为J(A,B) = 1.

    如上图,如果所交的区域或者说样本集比较大的话,我们就可以说他们之间的相似性较大。


    维基链接:https://en.wikipedia.org/wiki/Jaccard_index

    2.高斯相似性:高斯核函数的相似性,可见https://www.cnblogs.com/yan2015/p/5182144.html

    3.余弦相似性:余弦相似度是衡量内积空间的两个非零向量之间相似度的度量,它衡量它们之间角度的余弦。具体就是根据词句的内容以及词频,生成向量。计算他们之间的余弦大小,越接近1越相似。更详细的介绍可点击链接http://www.ruanyifeng.com/blog/2013/03/cosine_similarity.html



    常见的相似性度量:见地址https://blog.csdn.net/xholes/article/details/52708854

    展开全文
  • 时间序列相似性度量-DTW

    万次阅读 多人点赞 2019-01-25 16:44:59
    最近项目中遇到求解时间序列相似性问题,这里序列也可以看成向量。在传统算法中,可以用余弦相似度和pearson相关系数来描述两个序列的相似度。但是时间序列比较特殊,可能存在两个问题: 两段时间序列长度不同。...

    1. 背景

    最近项目中遇到求解时间序列相似性问题,这里序列也可以看成向量。在传统算法中,可以用余弦相似度和pearson相关系数来描述两个序列的相似度。但是时间序列比较特殊,可能存在两个问题:

    1. 两段时间序列长度不同。如何求相似度?
    2. 一个序列是另一个序列平移之后得到的。如何求相似距离?

    第一个问题,导致了根本不能用余弦相似度和pearson相关系数来求解相似。第二个问题,导致了也不能基于欧式距离这样的算法,来求解相似距离。比如下面两个长度不同的序列:

    s1 = [1, 2, 0, 1, 1, 2]
    s2 = [1, 0, 1]
    

    本文记录一种算法,一方面:如果两个序列中的其中一个序列是另一个序列的平移序列,则可以比较合理的求出两个序列的相似距离。另一方面:也可以求解长度不同序列的相似距离。主要参考:dtaidistance 这个项目的源码和其中的Dynamic Time Warping (DTW)思想。

    同时基于这个算法,先计算相似距离,再把相似距离通过 11+dist\frac{1}{1+dist} 转化为相似度。这样就可以得到长度不同向量的相似度。

    2. 核心思想

    Dynamic Time Warping (DTW) 本质上和通过动态规划来计算这个序列的相似距离。其实这和求解字符串的最长公共子串、子序列这类问题本质比较类似,参考:

    这里基于动态规划构建序列a和序列b的距离矩阵dp[i][j],其中dp[i][j]表示序列a[0:i]和b[0:j]之间的相似距离的平方。并且有:
    dp[i][j]={(a[0]b[0])2i = 0, j = 0(a[0]b[j])2+dp[0][j1]i = 0(a[i]b[0])2+dp[i1][0]j = 0(a[i]b[j])2+min(dp[i1][j],dp[j1][i],dp[i1][j1])i,j>0 dp[i][j] = \begin{cases} (a[0] - b[0])^2 \quad\quad &\text{i = 0, j = 0} \\ (a[0] - b[j])^2 + dp[0][j-1] \quad\quad &\text{i = 0} \\ (a[i] - b[0])^2 + dp[i-1][0] \quad\quad &\text{j = 0} \\ (a[i] - b[j])^2 + min(dp[i-1][j],dp[j-1][i],dp[i-1][j-1]) \quad\quad &i,j > 0 \end{cases}

    所以dp[len(a)-1][len(b)-1] 就是相似距离的平方,最后开方就是两个时间序列的相似距离,这也就是DTW算法核心实现。实际上,上文的那个github核心代码其实也就是这么写的,只不过在此基础上加了其他参数、画图、层次聚类的代码实现而已。

    3. 实现

    在实际使用中解读了dtaidistance这个项目的源码,其中除去所有参数后,DTW最简单的实现如下:

    import numpy as np
    
    float_formatter = lambda x: "%.2f" % x
    np.set_printoptions(formatter={'float_kind': float_formatter})
    
    
    def TimeSeriesSimilarity(s1, s2):
        l1 = len(s1)
        l2 = len(s2)
        paths = np.full((l1 + 1, l2 + 1), np.inf)  # 全部赋予无穷大
        paths[0, 0] = 0
        for i in range(l1):
            for j in range(l2):
                d = s1[i] - s2[j]
                cost = d ** 2
                paths[i + 1, j + 1] = cost + min(paths[i, j + 1], paths[i + 1, j], paths[i, j])
    
        paths = np.sqrt(paths)
        s = paths[l1, l2]
        return s, paths.T
    
    
    if __name__ == '__main__':
        s1 = [1, 2, 0, 1, 1, 2]
        s2 = [1, 0, 1]
    
        distance, paths = TimeSeriesSimilarity(s1, s2)
        print(paths)
        print("=" * 40)
        print(distance)
    

    输出

    [[0.00 inf inf inf inf inf inf]
    [inf 0.00 1.00 1.41 1.41 1.41 1.73]
    [inf 1.00 2.00 1.00 1.41 1.73 2.45]
    [inf 1.00 1.41 1.41 1.00 1.00 1.41]]
    ========================================
    1.4142135623730951
    

    这里的矩阵
    [0.001.001.411.411.411.731.002.001.001.411.732.451.001.411.411.001.001.41] \begin{bmatrix} 0.00 & 1.00 & 1.41 & 1.41 & 1.41 & 1.73 \\ 1.00 & 2.00 & 1.00 & 1.41 & 1.73 & 2.45 \\ 1.00 & 1.41 & 1.41 & 1.00 & 1.00 & 1.41 \end{bmatrix}

    就是dp[i][j]。这里代码用另一种写法实现了求解dp[i][j]。并且矩阵右下角元素1.41,就是我们求解的相似距离。

    4. 改进

    其实在实际使用中,我们发现该算法对周期序列的距离计算不是很好。尤其两个序列是相同周期,但是是平移后的序列。如下:

    s1 = np.array([1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1])
    s2 = np.array([0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2])
    s3 = np.array([0.8, 1.5, 0, 1.2, 0, 0, 0.6, 1, 1.2, 0, 0, 1, 0.2, 2.4, 0.5, 0.4])
    

    用图表展示:

    很明显从图中可以看到s1s_1s2s_2是相同的时间序列,但是s1s_1s2s_2平移后得到的,s3s_3是我随意构造的一个序列。但是,现在用上面的算法求解,得:
    dist(s1,s2)=2.0dist(s1,s3)=1.794435844492636 \begin{aligned} dist(s_1,s_2) &= 2.0 \\ dist(s_1,s_3) &= 1.794435844492636 \end{aligned}

    我们发现s1s_1s3s_3反而比较像,这是我们不能接受的。因此,这里需要对算法有个改进。以下有两个改进策略。

    4.1 改进策略1

    目的是想求得一个惩罚系数α\alpha,这个α\alpha和原算法的distance相乘,得到更新后的distance。首先基于原算法包dtaidistance,可以求出dp[i][j]从左上角,到右下角的最优路径。

    其实这样的最优路径,可以用图示表示,比如s1s_1s2s_2的dp[i][j]的最优路径:

    再比如s1s_1s3s_3的dp[i][j]的最优路径:

    其实可以很明显看到,s1s_1s2s_2的最优路径拐点比较少,对角直线很长。而s1s_1s3s_3的拐点比较多,对角直线很短。因此我基于这个考虑进行优化,公式如下:
    α=1i=1ncomLeni2seqLen2 \alpha = 1- \sqrt{\sum_{i=1}^n \frac{comLen_i^2}{seqLen^2}}

    其中seqLen 是这个图中最优路径节点个数,comLenicomLen_i表示每段对角直线的长度。求和后开发表示一个长度系数,这个长度系数越大,表示对角直线越长。最后1减去这个长度系数得到,我们要的衰减系数α\alpha。以下是代码实现:

    说明:这里best_path()是直接摘自dtaidistance,TimeSeriesSimilarity()方法是修改自这个项目。

    import numpy as np
    import math
    
    
    def get_common_seq(best_path, threshold=1):
        com_ls = []
        pre = best_path[0]
        length = 1
        for i, element in enumerate(best_path):
            if i == 0:
                continue
            cur = best_path[i]
            if cur[0] == pre[0] + 1 and cur[1] == pre[1] + 1:
                length = length + 1
            else:
                com_ls.append(length)
                length = 1
            pre = cur
        com_ls.append(length)
        return list(filter(lambda num: True if threshold < num else False, com_ls))
    
    
    def calculate_attenuate_weight(seqLen, com_ls):
        weight = 0
        for comlen in com_ls:
            weight = weight + (comlen * comlen) / (seqLen * seqLen)
        return 1 - math.sqrt(weight)
    
    
    def best_path(paths):
        """Compute the optimal path from the nxm warping paths matrix."""
        i, j = int(paths.shape[0] - 1), int(paths.shape[1] - 1)
        p = []
        if paths[i, j] != -1:
            p.append((i - 1, j - 1))
        while i > 0 and j > 0:
            c = np.argmin([paths[i - 1, j - 1], paths[i - 1, j], paths[i, j - 1]])
            if c == 0:
                i, j = i - 1, j - 1
            elif c == 1:
                i = i - 1
            elif c == 2:
                j = j - 1
            if paths[i, j] != -1:
                p.append((i - 1, j - 1))
        p.pop()
        p.reverse()
        return p
    
    
    def TimeSeriesSimilarity(s1, s2):
        l1 = len(s1)
        l2 = len(s2)
        paths = np.full((l1 + 1, l2 + 1), np.inf)  # 全部赋予无穷大
        paths[0, 0] = 0
        for i in range(l1):
            for j in range(l2):
                d = s1[i] - s2[j]
                cost = d ** 2
                paths[i + 1, j + 1] = cost + min(paths[i, j + 1], paths[i + 1, j], paths[i, j])
    
        paths = np.sqrt(paths)
        s = paths[l1, l2]
        return s, paths.T
    
    
    if __name__ == '__main__':
        # 测试数据
        s1 = np.array([1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1])
        s2 = np.array([0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2])
        s3 = np.array([0.8, 1.5, 0, 1.2, 0, 0, 0.6, 1, 1.2, 0, 0, 1, 0.2, 2.4, 0.5, 0.4])
    
        # 原始算法
        distance12, paths12 = TimeSeriesSimilarity(s1, s2)
        distance13, paths13 = TimeSeriesSimilarity(s1, s3)
    
        print("更新前s1和s2距离:" + str(distance12))
        print("更新前s1和s3距离:" + str(distance13))
    
        best_path12 = best_path(paths12)
        best_path13 = best_path(paths13)
    
        # 衰减系数
        com_ls1 = get_common_seq(best_path12)
        com_ls2 = get_common_seq(best_path13)
    
        # print(len(best_path12), com_ls1)
        # print(len(best_path13), com_ls2)
        weight12 = calculate_attenuate_weight(len(best_path12), com_ls1)
        weight13 = calculate_attenuate_weight(len(best_path13), com_ls2)
    
        # 更新距离
        print("更新后s1和s2距离:" + str(distance12 * weight12))
        print("更新后s1和s3距离:" + str(distance13 * weight13))
    

    输出:

    更新前s1和s2距离:2.0
    更新前s1和s3距离:1.794435844492636
    更新后s1和s2距离:0.6256314581274465
    更新后s1和s3距离:0.897217922246318
    

    结论:
    用新的算法更新后,我们会发现s1和s2距离比s1和s3的距离更加接近了,这就是我们要的结果。

    4.2 改进策略2

    也想求得一个惩罚系数α\alpha。方案如下:

    1. 先求解两个序列seq1和seq2的最长公共子串,长度记为a。
    2. 因为seq1和seq2是数值序列,在求最长公共子串时,设置了一个最大标准差的偏移容忍。也就是说,两个数值在这个标准差内,认为也是公共子串中的一部分。
    3. 衰减系数:α=1a×alen(seq1)×len(seq2)\alpha = 1 - \frac{a \times a}{len(seq1) \times len(seq2)}

    也就是说,两个数值序列的最长公共子串越长,则衰减系数越小。这里把:s2 = np.array([0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2])改成s2 = np.array([0, 1, 1, 2, 0, 1, 1.7, 2, 0, 1, 1, 2, 0, 1, 1, 2]),来验证最大标准差的偏移容忍。

    实际代码实现和效果如下:

    import numpy as np
    
    float_formatter = lambda x: "%.2f" % x
    np.set_printoptions(formatter={'float_kind': float_formatter})
    
    
    def TimeSeriesSimilarityImprove(s1, s2):
        # 取较大的标准差
        sdt = np.std(s1, ddof=1) if np.std(s1, ddof=1) > np.std(s2, ddof=1) else np.std(s2, ddof=1)
        # print("两个序列最大标准差:" + str(sdt))
        l1 = len(s1)
        l2 = len(s2)
        paths = np.full((l1 + 1, l2 + 1), np.inf)  # 全部赋予无穷大
        sub_matrix = np.full((l1, l2), 0)  # 全部赋予0
        max_sub_len = 0
    
        paths[0, 0] = 0
        for i in range(l1):
            for j in range(l2):
                d = s1[i] - s2[j]
                cost = d ** 2
                paths[i + 1, j + 1] = cost + min(paths[i, j + 1], paths[i + 1, j], paths[i, j])
                if np.abs(s1[i] - s2[j]) < sdt:
                    if i == 0 or j == 0:
                        sub_matrix[i][j] = 1
                    else:
                        sub_matrix[i][j] = sub_matrix[i - 1][j - 1] + 1
                        max_sub_len = sub_matrix[i][j] if sub_matrix[i][j] > max_sub_len else max_sub_len
    
        paths = np.sqrt(paths)
        s = paths[l1, l2]
        return s, paths.T, [max_sub_len]
    
    
    def calculate_attenuate_weight(seqLen1, seqLen2, com_ls):
        weight = 0
        for comlen in com_ls:
            weight = weight + comlen / seqLen1 * comlen / seqLen2
        return 1 - weight
    
    
    if __name__ == '__main__':
        # 测试数据
        s1 = np.array([1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1])
        s2 = np.array([0, 1, 1, 2, 0, 1, 1.7, 2, 0, 1, 1, 2, 0, 1, 1, 2])
        s3 = np.array([0.8, 1.5, 0, 1.2, 0, 0, 0.6, 1, 1.2, 0, 0, 1, 0.2, 2.4, 0.5, 0.4])
    
        # 原始算法
        distance12, paths12, max_sub12 = TimeSeriesSimilarityImprove(s1, s2)
        distance13, paths13, max_sub13 = TimeSeriesSimilarityImprove(s1, s3)
    
        print("更新前s1和s2距离:" + str(distance12))
        print("更新前s1和s3距离:" + str(distance13))
    
        # 衰减系数
        weight12 = calculate_attenuate_weight(len(s1), len(s2), max_sub12)
        weight13 = calculate_attenuate_weight(len(s1), len(s3), max_sub13)
    
        # 更新距离
        print("更新后s1和s2距离:" + str(distance12 * weight12))
        print("更新后s1和s3距离:" + str(distance13 * weight13))
    

    输出:

    更新前s1和s2距离:2.0223748416156684
    更新前s1和s3距离:1.794435844492636
    更新后s1和s2距离:0.47399410350367227
    更新后s1和s3距离:1.6822836042118463
    

    结论:
    用新的算法更新后,我们会发现s1和s2距离比s1和s3的距离更加接近了,这就是我们要的结果。

    5. 参考

    1. https://github.com/wannesm/dtaidistance
    2. 两个字符串的最长子串
    3. 两个字符串的最长子序列
    展开全文
  • 轨迹相似性度量

    万次阅读 2018-07-05 20:34:43
    轨迹相似性对于移动对象分析来说是一个重要的指标,如何度量轨迹相似性,则是中心问题。轨迹相似性通常用一个距离函数来计算,现行比较常用的轨迹相似性度量指标有多种,而且分别有各自的优势,如何选择不同的轨迹...

        轨迹相似性对于移动对象分析来说是一个重要的指标,如何度量轨迹相似性,则是中心问题。轨迹相似性通常用一个距离函数来计算,现行比较常用的轨迹相似性度量指标有多种,而且分别有各自的优势,如何选择不同的轨迹相似性度量是进行轨迹聚类的关键。

        在介绍轨迹相似性之前,先考虑如何定义点与轨迹之间的相似性[1]。假设有查询点q与轨迹A,q与A之间的相似性通常定义如下:

     

    p'为轨迹A上按照d(.)计算距离最小的点。因此,点到轨迹的距离本质上还是计算点到点的距离,核心部分在于d(.)的定义,计算两个点距离时,可以选择L-P范数,可以选择欧氏距离,切式距离,曼哈顿距离等各种距离计算方法。对于经纬度数据,计算大圆距离显然比直接计算经纬度欧氏距离更准确。

        轨迹与轨迹之间的相似度有多种经典度量指标。

    1. Closest-Pair Distance(CPD)
    2. Sum-of-Pairs Distance (SPD)
    3. DTW
    4. LCSS
    5. EDR       

    CPD距离即找出两条轨迹之间两点距离最近的两个点,以该点对的距离作为轨迹距离。计算公式如下所示:


    CPD距离定义简单,但是容易受到局部极端情况的影响,考虑两条轨迹在某点相交,然而整体情况差异很大,这种情况用CPD距离显然不合适。总体来说,这种方法不是很好。

    SPD[2]距离对两条轨迹对应序号的点对计算距离并求和,以该求和距离作为轨迹相似性分数。计算公式如下:


    观察SPD距离发现,SPD距离要求轨迹A和轨迹B具有相同的轨迹点个数。在此基础上可以做出一些改进[3],以便可以适应轨迹长度不同的情况,同时考虑轨迹方向的影响,参考Hausdorff distance algorithm ,类似于对称SPD距离。

     

    总体距离分数为score = (d(A,B) + d(B,A)) / 2。对于d(A,B),按照轨迹点index顺序,找出轨迹A上每个点到轨迹B的最短距离,求和并除以总点数。

    DTW距离的计算不受到轨迹点数是否相同的限制,计算公式为:


    给定轨迹A<a1,a2,...an>和轨迹B<b1,b2,...bm>,Head(A)表示a1,Rest(A)表示<a2,a3...an>。

    噪声点存在的情况下,之前的计算方法会受到很大影响,而LCSS方法[4]在解决噪声点影响时很有效。LCSS全称为最大公共子串,假定A和B是点数分别为n和m,给定整数δ 和距离阈值ε 。LSSS的定义如下:


    与DTW一样,计算方法用一种动态规划的形式定义。

    虽然LCSS距离考虑到噪声的影响,但是LCSS无法区分具有相同公共子序列的轨迹,因此提出EDR[5]距离。


    n,m为轨迹A,B的长度。subcost定义为:


    轨迹相似性度量在轨迹聚类,移动目标分析中是个关键的问题,考虑到数据量,计算复杂度,噪声等影响因素,不同情况下需要选择不同度量。





    参考资料:

    《Computing with Spatial Trajectories》 郑宇 

    Agrawal, R., Faloutsos, C., Swami, A.N.: Efficient similarity search in sequence databases.
    FODO pp. 69–84 (1993)

    Chen, L., Ozsu, M.T., Oria, V.: Robust and fast similarity search for moving object trajectories.
    SIGMOD (2005)

    Chen, Z., Shen, H.T., Zhou, X., Zheng, Y., Xie, X.: Searching trajectories by locations - an

    efficiency study. SIGMOD (2010) 

    Jon Froehlich John Krumm: Route Prediction from Trip Observations(2008)

















    展开全文
  • 论文相似性检测工具(论文查重软件)

    千次下载 热门讨论 2010-09-28 20:16:03
    由武汉大学信息管理学院出版科学系教师沈阳副教授研发的ROST 文档相似性检测工具可以有效检测论文的抄袭相似情况,经过六年的研发,终于推出了功能强劲的6.0版本,在定版过程中得到了武汉大学信息管理学院多位专家...
  • FTrees简介FTrees(Feature Trees)是一种高效的药效团模型相似性搜索软件工具,可以促进虚拟高通量筛选(HTS)。特征树描述符捕获分子的整体拓扑结构及其药效团特性。相似性基于两个分子的描述符进行比对。FTrees主要...

    FTrees简介

    FTrees(Feature Trees)是一种高效的药效团模型相似性搜索软件工具,可以促进虚拟高通量筛选(HTS)。特征树描述符捕获分子的整体拓扑结构及其药效团特性。相似性基于两个分子的描述符进行比对。

    FTrees主要应用

    先导化合物的发现

    骨架跃迁:结构不同的分子,具有高度相似的特征树。

    高通量筛选分析(HTS)

    命中率和正交结果:FTrees在基准数据集上超越了行业标准。

    虚拟筛选

    化学数据挖掘:能够超高速的从数十亿虚拟化合物中搜索相似骨架。

    参考资料

    [1]   Hans Briem, Uta F. Lessel. In vitro and in silico affinity fingerprints: Finding similarities beyond structural classes. Perspectives in Drug Discovery and Design, 2000, 20 (1), 231-244

    [2]   Thierry Kogej, Ola Engkvist, Niklas Blomberg, Sorel Muresan Multifingerprint based similarity searches for targeted class compound selection. Journal of Chemical Information and Modeling, 2006, 46 (3), 1201-1213

    [3]   Markus Böhm, Tong-Ying Wu, Holger Claußen, Christian Lemmen Similarity Searching and Scaffold Hopping in Synthetically Accessible Combinatorial Chemistry Spaces. Journal of Medicinal Chemistry, 2008, 51 (8), 2468-2480

    展开全文
  • SSIM(structural similarity index),结构相似性,是一种衡量两幅图像相似度的指标。 计算方法 SSIM使用两张图片的均值、方法、协方差进行计算,具体的计算方法如下: 结构相似性的范围为0到1 。当两张图像一模一样...
  • 序列的相似性

    千次阅读 2019-05-04 08:02:20
    序列的相似性可以是定量的数值,也可以是定性的描述。相似度是一个数值,反映两条序列的相似程度。关于两条序列之间的关系,有许多名词,如相同、相似、同源、同功、直向同源、共生同源等。在进行序列比较时经常使用...
  • 句子相似性

    千次阅读 2019-03-07 16:00:27
    在nlp任务中,经常会遇到求解相似语句判断的场景,这就涉及到了句子的相似性判断。目前常用的两种方法是基于word-level级别和sentence-level级别。 一、Word-level的思想是通过对句子进行分词,分别计算两个比较...
  • 序列相似性比较与同源性分析

    千次阅读 2019-09-24 15:22:44
    序列相似性比较与同源性分析 首先应该注意区分序列相似性与序列同源性的关系,序列相似不一定同源,但是判定同源性关系的时候有些算法(Maximum likelihood除外)要考虑到序列相似性。序列相似性是将待...
  • TF-IDF结合余弦相似性 判断文章相似性
  • 信号相似性

    千次阅读 2015-02-06 11:38:13
    信号相似性的描述 在很多的应用场合,经常要描述两个信号的相似性。比如在雷达的信号检测中,要比较所接收的信号是否就是发射信号的延时。有时候,甚至还要描述一个信号本身的相似性,比如在语音编码中,要通过语音...
  • 流动相似性例子

    2018-09-24 10:51:41
     在飞机设计的时候,我们喜欢把缩小版的模型放风洞中去吹,这时我们显然希望模型能最大限度地模拟真实尺寸飞机的情况,也就是模型的流体动力学模型要尽可能和真实飞机相似,流体相似性于是就登场了。 何为流体相似...
  • jaccard相似性度量

    千次阅读 2018-09-24 13:43:33
    Jaccard /IOU ...定义:度量两个集合之间相似性,index值越大则两个集合越相似,或者说两个集合重叠区域越多; 公式: Jaccard distance 公式:两个集合之间相似性度量; 广义Jaccard distance ...
  • 相似性比较

    千次阅读 2017-03-31 21:14:26
    在做分类时常常需要估算不同样本之间的相似性度量(Similarity Measurement),这时通常采用的方法就是计算样本间的“距离”(Distance)。采用什么样的方法计算距离是很讲究,甚至关系到分类的正确与否。本文的目的就是...
  • 相似性度量外围文档资料

    热门讨论 2017-02-26 10:35:43
    相似性度量外围文档资料,为博客http://blog.csdn.net/wangyaninglm/article/details/43853435的补充
  • 节点相似性指标

    千次阅读 2020-06-24 21:38:20
    基于局部信息的节点相似性指标 对于一般的网络,两个节点的共同邻居的数量越多,这两个节点越相似,也就更倾向于相互连接。 其中: Γ(x)\Gamma (x)Γ(x) 为节点x的邻居节点的集合 k(x)=∣Γ(x)∣k(x)=\left | \...
  • 相似性度量

    千次阅读 2014-03-21 20:14:10
    在模式识别、计算机视觉等多个领域,都会涉及到相似性的度量这一问题,用来衡量不同对象间的差异性(距离)或相似性(相似度)。这里的对象可以是网页,图像,也可以是文本,集合,但最终在数学上都可以表示为向量...
  • 相似性分析之Jaccard相似系数

    千次阅读 2017-07-27 18:16:00
    Jaccard, 又称为Jaccard相似系数(Jaccard similarity coefficient)用于比较有限样本集之间的相似性与差异性。Jaccard系数值越大,样本相似度越高 公式: 假设arr1 = [11, 2, 3, 8, 10, 0, 2, 0, 0, 2, 1, 0, 0, ...
  • MATLAB余弦相似性学习

    千次阅读 2019-08-24 17:05:20
    根据余弦相似性原理判断两篇文章的相似程度。原理很简单,大致就是利用几个关键字组成一个特征向量,然后统计两篇文章各自对应的特征向量的值。最后计算两个特征矢量点积后的结果,即利用余弦值。如果值为1,表示两...
  • 相似性度量总结

    万次阅读 2015-12-05 20:14:13
    又机器学习中的相似性度量 、 余弦距离、欧氏距离和杰卡德相似性度量的对比分析 整理而成在做分类时常常需要估算不同样本之间的相似性度量(Similarity Measurement),这时通常采用的方法就是计算样本间的“距离”...
  • 常用的相似性度量指标

    千次阅读 2019-05-14 19:36:01
    相似性度量,即综合评定两个事物之间相近程度的一种度量。两个事物越接近,它们的相似性度量也就越大,而两个事物越疏远,它们的相似性度量也就越小。相似性度量的给法种类繁多,一般根据实际问题进行选用。 1. ...
  • 时间序列相似性

    万次阅读 2017-10-11 14:59:17
    对于两个序列来说,如果要比较两个波形的相似程度,可以使用DWT(动态时间规整)的方法...DTW通过把时间序列进行延伸和缩短,来计算两个时间序列性之间的相似性。 1,两个要进行匹配的数据A=[A1,A2,...An]和B=[B1,B
  • 相似性匹配

    千次阅读 2013-06-06 23:37:30
    对于图像的相似性匹配常用的方法包括以下几种: 1. 获取(区域或全局)直方图(颜色直方图,灰度直方图,LBP,HOG等)直接利用各种相似性距离度量,或者计算其各阶矩,或者对其曲线进行二值化,然后进行比较。 ...
  • 常用相似性度量(距离 相似系数)

    千次阅读 2018-05-22 10:32:03
    在分类聚类算法,推荐系统中,常要用到两个输入变量(通常是特征向量的形式)距离的计算,即相似性度量.不同相似性度量对于算法的结果,有些时候,差异很大.因此,有必要根据输入数据的特征,选择一种合适的相似性度量方法.令...
  • 图像相似性搜索思路

    千次阅读 2018-06-26 22:48:56
    为什么做图像相似性搜索?通过图像找相似性比较容易。应用场景:通过图片找相似作品。比如足迹可以使用。新发布作品,通过图片找最相似的作品。各种推荐场景,可以把图像相似性的特征用在计算相似作品上面。算法思路...
  • python 地址相似性判断

    2019-10-04 16:52:08
    地址相似性判断在金融反欺诈中有重要的应用,通过相似的地址判断,构建知识图谱,可以获取申请客户是否属于同公司的欺诈申请。 二、关键步骤 (1)地址分词 (2)制作地址语料库 (3)相似性判断 三、python...
  • RDKit | 基于分子指纹的分子相似性

    千次阅读 2019-10-14 10:52:44
    分子相似性相似性原理(similar property principle)指出,总体相似的分子应具有相似的生物活性。 相似性评估 化合物的指纹对于使用计算机考虑化合物的相似性是必需的。已经提出了各种评估方法,但是最常用的...
  • title: Pytorch 孪生lstm 句子相似性 date: 2020-03-22 23:30:31 tags: NLP Pytorch 孪生lstm 句子相似性 复现论文 《Siamese Recurrent Architectures for Learning Sentence Similarity》 挖个坑,最近上午把这篇...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,191
精华内容 12,076
关键字:

相似性