Cálculo de distancia y similitud

1. Similitud de coseno

Computación acelerada consulte este artículo

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. Distancia 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. Distancia 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. Distancia de Hamming

El número de caracteres diferentes en las posiciones correspondientes de dos cadenas de igual longitud.

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)

Distancia de V. Chebyshev

La distancia de Chebyshev se originó a partir de la jugada del rey en el ajedrez. En el ajedrez, el rey solo puede dar un paso en las 8 casillas circundantes a la vez. Luego, si quieres caminar desde la casilla A (x1, y1) hasta la casilla B ( x2), y2) ¿Es necesario realizar al menos algunos pasos? Encontrará que el número mínimo de pasos es siempre máximo (| x2-x1 |, | y2-y1 |) pasos. Existe un método de medición de distancia similar llamado distancia 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. Distancia 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. Distancia de Minkowski

p = 2 es la distancia euclidiana y p = 1 es la distancia de Manhattan. En el caso extremo en el que p es infinito, se puede obtener la distancia de Chebyshev:

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 la distancia

La distancia de edición , también conocida como distancia de Levenshtein (distancia de Levenshtein, también conocida como distancia de edición), se refiere al número mínimo de operaciones de edición necesarias para convertir dos cadenas de una a otra. Si su distancia es mayor, son las más diferentes. Las operaciones de edición permitidas incluyen reemplazar un carácter por otro , insertar un carácter y eliminar un carácter .

Método 1: ajustar el paquete

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

Método 2: programación 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)

Nueve. Similitud 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. Distancia de 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)