Cálculo de distância e similaridade

1. Similaridade de cosseno

Computação acelerada consulte este artigo

from math import *

def square_rooted(x):
    return round(sqrt(sum([a*a for a in x])), 3)

def cosine_similarity(x,y):
   numerator = sum(a*b for a, b in zip(x,y))
   denominator = square_rooted(x)*square_rooted(y)
   return round(numerator/float(denominator),3)

res = cosine_similarity([1, 0], [0,1])
print('==res:', res)

2. Distância euclidiana

from math import *
def euclidean_distance(x, y):
    return sqrt(sum(pow(a - b, 2) for a, b in zip(x, y)))


res = euclidean_distance([0, 1], [1, 0])
print('res:', res)

3. Distância de Manhattan

from math import *

def manhattan_distance(x,y):
    return sum(abs(a-b) for a, b in zip(x,y))
print(manhattan_distance([1, 0], [0, 1]))

4. Distância de Hamming

O número de caracteres diferentes nas posições correspondentes de duas sequências de comprimento igual.

def hamming_distance(s1, s2):
    """Return the Hamming distance between equal-length sequences"""
    if len(s1) != len(s2):
        raise ValueError("Undefined for sequences of unequal length")
    return sum(a != b for a, b in zip(s1, s2))

res = hamming_distance('12','13')
print('res:', res)

Distância de V. Chebyshev

A distância Chebyshev originou-se do movimento do rei no xadrez. No xadrez, o rei só pode dar um passo nas 8 casas circundantes de cada vez. Então, se você quiser caminhar da casa A (x1, y1) para a casa B ( x2), y2) Pelo menos algumas etapas precisam ser executadas? Você descobrirá que o número mínimo de etapas é sempre o máximo (| x2-x1 |, | y2-y1 |) etapas. Existe um método de medição de distância semelhante denominado distância de Chebyshev.

def chebyshev_distance(p, q):
    assert len(p) == len(q)
    return max([abs(x - y) for x, y in zip(p, q)])
res = chebyshev_distance([0,0], [1,3])
print('res:', res)

Seis. Distância de Ran

def canberra_distance(p, q):
    n = len(p)
    distance = 0
    for i in range(n):
        if p[i] == 0 and q[i] == 0:
            distance += 0
        else:
            distance += abs(p[i] - q[i]) / (abs(p[i]) + abs(q[i]))
    return distance

res = canberra_distance([1,0], [0,1])
print('res:', res)

7. Distância de Minkowski

p = 2 é a distância euclidiana ep = 1 é a distância de Manhattan. No caso extremo, quando p é infinito, a distância de Chebyshev pode ser obtida:

def minkowski_distance(p, q, n):
    assert len(p) == len(q)
    return sum([abs(x - y) ** n for x, y in zip(p, q)]) ** (1. / n)


res = minkowski_distance([1, 0], [0, 1], n=2.)
print('res:', res)

8. Editar distância

A distância de edição , também conhecida como distância de Levenshtein (distância de Levenshtein, também conhecida como distância de edição), refere-se ao número mínimo de operações de edição necessárias para converter duas strings de uma para a outra. Se a distância for maior, elas serão mais diferentes. As operações de edição permitidas incluem a substituição de um caractere por outro , a inserção de um caractere e a exclusão de um caractere .

Método 1: ajuste o pacote

import Levenshtein
texta = '者記聞新'
textb = '浪(第'
print(Levenshtein.distance(texta, textb))

Método 2: programação dinâmica

import os
import numpy as np
def edit_distance(S1,S2):
    #S1列　S2行
    mat = [[0] *(len(S1)+1) for i in range(len(S2)+1)]
    # print('mat:', mat)
    for i in range(len(S2)):
        mat[i+1][0] = mat[i][0]+1
    # print('mat:', mat)
    for i in range(len(S1)):
        mat[0][i+1] = mat[0][i]+1
    # print('mat:\n', np.array(mat))
    #相等就为０　不想等加１
    for i in range(len(S2)):
        for j in range(len(S1)):
            if S2[i] == S1[j]:
                # print('S2[i]:', S2[i])
                mat[i + 1][j + 1] = min(mat[i][j] + 0, mat[i + 1][j]+1, mat[i][j + 1]+1)
            else:
                mat[i + 1][j + 1] = min(mat[i][j] + 1, mat[i + 1][j]+1, mat[i][j + 1]+1)
    # print('mat:\n', np.array(mat))
    dis = mat[-1][-1]
    print('dis:', dis)
    return dis
# S1 = 'iva1'
# S2 = 'iva'
S2 = '者記聞新'
S1 = '浪(第'
dis = edit_distance(S1, S2)
print('dis:', dis)

Nove. Semelhança de Jackard

def jaccard_sim(a, b):
    unions = len(set(a).union(set(b)))
    intersections = len(set(a).intersection(set(b)))
    return intersections / unions

a = ['1', '0']
b = ['1', '1', '1']
res = jaccard_sim(a, b)
print('res:', res)

10. Distância dos dados

def dice_coefficient(a, b):
    """dice coefficient 2nt/na + nb."""
    intersections = len(set(a).intersection(set(b)))
    return intersections * 2.0/(len(set(a)) + len(set(b)))

res =  dice_coefficient(a = [1, 0], b =[0, 1])
print('===res:',res)