Python机器学习中实现距离和相似性计算详解

def EuclideanDistance(x, y):
    import numpy as np
    x = np.array(x)
    y = np.array(y)
    return np.sqrt(np.sum(np.square(x-y)))

def ManhattanDistance(x, y):
    import numpy as np
    x = np.array(x)
    y = np.array(y)
    return np.sum(np.abs(x-y))

def ChebyshevDistance(x, y):
    import numpy as np
    x = np.array(x)
    y = np.array(y)
    return np.max(np.abs(x-y))

def MahalanobisDistance(x, y):
    '''
    马氏居立中的(x,y)与欧几里得距离的(x,y)不同,欧几里得距离中的(x,y)指2个样本，每个样本的维数为x或y的维数；这里的(x,y)指向量是2维的，样本个数为x或y的维数，若要计算n维变量间的马氏距离则需要改变输入的参数如(x,y,z)为3维变量。
    '''
    import numpy as np
    x = np.array(x)
    y = np.array(y)
    
    X = np.vstack([x,y])
    X_T = X.T
    sigma = np.cov(X)
    sigma_inverse = np.linalg.inv(sigma)
    
    d1=[]
    for i in range(0, X_T.shape[0]):
        for j in range(i+1, X_T.shape[0]):
            delta = X_T[i] - X_T[j]
            d = np.sqrt(np.dot(np.dot(delta,sigma_inverse),delta.T))
            d1.append(d)
        
    return d1

def moreCos(a,b):
    sum_fenzi = 0.0
    sum_fenmu_1,sum_fenmu_2 = 0,0
    for i in range(len(a)):
        sum_fenzi += a[i]*b[i]
        sum_fenmu_1 += a[i]**2 
        sum_fenmu_2 += b[i]**2 

    return sum_fenzi/( sqrt(sum_fenmu_1) * sqrt(sum_fenmu_2) )

def MinkowskiDistance(x, y, p):
    import math
    import numpy as np
    zipped_coordinate = zip(x, y)
    return math.pow(np.sum([math.pow(np.abs(i[0]-i[1]), p) for i in zipped_coordinate]), 1/p)

def hanmingDis(a,b):
    sumnum = 0
    for i in range(len(a)):
        if a[i]!=b[i]:
            sumnum += 1
    return sumnum

def jiekadeDis(a,b):
    set_a = set(a)
    set_b = set(b)
    dis = float(len( (set_a | set_b) - (set_a & set_b) ) )/ len(set_a | set_b)
    return dis

def jiekadeXSDis(a,b):
    set_a = set(a)
    set_b = set(b)
    dis = float(len(set_a & set_b)  )/ len(set_a | set_b)
    return dis

import math

def c_Pearson(x, y):

    x_mean, y_mean = sum(x)/len(x), sum(y)/len(y)
    cov =0.0
    x_pow = 0.0
    y_pow = 0.0
    for i in range(len(x)):
        cov += (x[i]-x_mean) *(y[i] - y_mean)
    for i in range(len(x)):
        x_pow += math.pow(x[i] - x_mean, 2)
    for i in range(len(x)):
        y_pow += math.pow(y[i] - y_mean, 2)
    sumBm = math.sqrt(x_pow * y_pow)
    p = cov / sumBm

    return p

import numpy as np

data=['a','b','c','a','a','b']
data1=np.array(data)
#计算信息熵的方法
def calc_ent(x):
    """
        calculate shanno ent of x
    """

    x_value_list = set([x[i] for i in range(x.shape[0])])
    ent = 0.0
    for x_value in x_value_list:
        p = float(x[x == x_value].shape[0]) / x.shape[0]
        logp = np.log2(p)
        ent -= p * logp

    return ent