余弦计算相似度度量
相似度度量（Similarity），即计算个体间的相似程度，相似度度量的值越小，说明个体间相似度越小，相似度的值越大说明个体差异越大。
对于多个不同的文本或者短文本对话消息要来计算他们之间的相似度如何，一个好的做法就是将这些文本中词语，映射到向量空间，形成文本中文字和向量数据的映射关系，通过计算几个或者多个不同的向量的差异的大小，来计算文本的相似度。下面介绍一个详细成熟的向量空间余弦相似度方法计算相似度
向量空间余弦相似度(Cosine Similarity)
余弦相似度用向量空间中两个向量夹角的余弦值作为衡量两个个体间差异的大小。余弦值越接近1，就表明夹角越接近0度，也就是两个向量越相似，这就叫"余弦相似性"。

上图两个向量a,b的夹角很小可以说a向量和b向量有很高的的相似性，极端情况下，a和b向量完全重合。如下图：

如上图二：可以认为a和b向量是相等的，也即a，b向量代表的文本是完全相似的，或者说是相等的。如果a和b向量夹角较大，或者反方向。如下图

如上图三: 两个向量a,b的夹角很大可以说a向量和b向量有很底的的相似性，或者说a和b向量代表的文本基本不相似。那么是否可以用两个向量的夹角大小的函数值来计算个体的相似度呢？
向量空间余弦相似度理论就是基于上述来计算个体相似度的一种方法。下面做详细的推理过程分析。
想到余弦公式，最基本计算方法就是初中的最简单的计算公式，计算夹角
 

图(4)
的余弦定值公式为：

但是这个是只适用于直角三角形的,而在非直角三角形中,余弦定理的公式是

图(5)
三角形中边a和b的夹角 的余弦计算公式为：

公式(2)
在向量表示的三角形中，假设a向量是（x1, y1），b向量是(x2, y2)，那么可以将余弦定理改写成下面的形式：

图(6)
向量a和向量b的夹角 的余弦计算如下
 

扩展，如果向量a和b不是二维而是n维，上述余弦的计算法仍然正确。假定a和b是两个n维向量，a是  ，b是  ，则a与b的夹角 的余弦等于：

余弦值越接近1，就表明夹角越接近0度，也就是两个向量越相似，夹角等于0，即两个向量相等，这就叫"余弦相似性"。
【下面举一个例子，来说明余弦计算文本相似度】
    举一个例子来说明，用上述理论计算文本的相似性。为了简单起见，先从句子着手。
　　       句子A：这只皮靴号码大了。那只号码合适
句子B：这只皮靴号码不小，那只更合适
怎样计算上面两句话的相似程度？
基本思路是：如果这两句话的用词越相似，它们的内容就应该越相似。因此，可以从词频入手，计算它们的相似程度。
第一步，分词。
句子A：这只/皮靴/号码/大了。那只/号码/合适。
句子B：这只/皮靴/号码/不/小，那只/更/合适。
第二步，列出所有的词。
这只，皮靴，号码，大了。那只，合适，不，小，很
第三步，计算词频。
句子A：这只1，皮靴1，号码2，大了1。那只1，合适1，不0，小0，更0
句子B：这只1，皮靴1，号码1，大了0。那只1，合适1，不1，小1，更1
第四步，写出词频向量。
　　句子A：(1，1，2，1，1，1，0，0，0)
　　句子B：(1，1，1，0，1，1，1，1，1)
到这里，问题就变成了如何计算这两个向量的相似程度。我们可以把它们想象成空间中的两条线段，都是从原点（[0, 0, ...]）出发，指向不同的方向。两条线段之间形成一个夹角，如果夹角为0度，意味着方向相同、线段重合,这是表示两个向量代表的文本完全相等；如果夹角为90度，意味着形成直角，方向完全不相似；如果夹角为180度，意味着方向正好相反。因此，我们可以通过夹角的大小，来判断向量的相似程度。夹角越小，就代表越相似。
使用上面的公式(4)
 
计算两个句子向量
句子A：(1，1，2，1，1，1，0，0，0)
和句子B：(1，1，1，0，1，1，1，1，1)的向量余弦值来确定两个句子的相似度。
计算过程如下：

计算结果中夹角的余弦值为0.81非常接近于1，所以，上面的句子A和句子B是基本相似的
由此，我们就得到了文本相似度计算的处理流程是:
    （1）找出两篇文章的关键词；
　（2）每篇文章各取出若干个关键词，合并成一个集合，计算每篇文章对于这个集合中的词的词频
　（3）生成两篇文章各自的词频向量；
　（4）计算两个向量的余弦相似度，值越大就表示越相似。


转自https://blog.csdn.net/u012160689/article/details/15341303

#简单的音频相似度对比 Demo
 
##环境
 AndroidStudio、MATLAB、Audacity
 ##基本思路和流程
 1. 录音，保存音频数据
 2. 从二进制文件中获取音频原始数据
 3. 音频滤波
 4. 计算音频信号短时能量
 5. 截取音频信号有效数据
 6. 对对比音频数据进行同上操作
 7. 计算标准音频与对比音频数据的余弦距离
 
##核心代码
 
	import java.io.DataInputStream;
	import java.io.IOException;
	
	/**
	 * Created by lzy on 2015/11/18.
	 */
	public class AudioDataOperate {
	
	    public static final int TYPE_16BIT = 1;
	    public static final double DATA_START_VALUE = 0.025;
	    public static final double DATA_END_VALUE = 0.025;
	
	    /**
	     * 按编码类型提取音频数据
	     *
	     * @param dis
	     * @param size
	     * @param type
	     * @return
	     */
	    public static short[] getAudioData(DataInputStream dis, int size, int type) {
	        short[] audioData = new short[size];
	        try {
	            byte[] tempData = new byte[2];
	            long audioDataSize = 0;
	            while (dis.read(tempData) != -1) {
	                // 每16位读取一个音频数据
	                audioData[(int) audioDataSize] = (short) (((tempData[0] & 0xff) << 8) | (tempData[1] & 0xff));
	                audioDataSize++;
	                if (audioDataSize == size) {
	                    break;
	                }
	            }
	        } catch (IOException e) {
	            e.printStackTrace();
	        }
	        return audioData;
	    }
	
	    /**
	     * 归一化
	     */
	    public static double[] normalize(short[] data) {
	        short max = findMax(data);
	        double[] result = new double[data.length];
	        for (int i = 0; i < data.length; i++) {
	            result[i] = ((double) data[i] / max);
	        }
	        return result;
	    }
	
	    /**
	     * 归一化
	     */
	    public static double[] normalize(double[] data) {
	        double max = findMax(data);
	        double[] result = new double[data.length];
	        for (int i = 0; i < data.length; i++) {
	            result[i] = data[i] / max;
	        }
	        return result;
	    }
	
	    /**
	     * 自身点乘
	     *
	     * @return
	     */
	    public static double[] dotProduct(double[] data) {
	        double[] result = new double[data.length];
	        for (int i = 0; i < data.length; i++) {
	            result[i] = data[i] * data[i];
	        }
	        return result;
	    }
	
	    /**
	     * 查找最大值
	     *
	     * @param data
	     * @return
	     */
	    private static short findMax(short[] data) {
	        short max = data[0];
	        for (int i = 0; i < data.length; i++) {
	            if (max < Math.abs(data[i])) {
	                max = (short) Math.abs(data[i]);
	            }
	        }
	        System.out.println("max :  " + max);
	        return max;
	    }
	
	    /**
	     * 查找最大值
	     *
	     * @param data
	     * @return
	     */
	    private static double findMax(double[] data) {
	        double max = data[0];
	        for (int i = 0; i < data.length; i++) {
	            if (max < Math.abs(data[i])) {
	                max = Math.abs(data[i]);
	            }
	        }
	        System.out.println("max :  " + max);
	        return max;
	    }
	
	    /**
	     * 生成窗函数
	     */
	    public static double[] generateWindows(int N, int i) {
	        // 使用最简单的矩形窗
	        double[] wins = new double[i * N];
	        for (int j = 0; j < i * N; j++) {
	            wins[j] = 1;
	        }
	        return wins;
	    }
	
	    /**
	     * 生成窗函数   hamming窗
	     */
	    public static double[] generateHammingWindows(int N, int i) {
	        // 使用最简单的矩形窗
	        double[] wins = new double[i * N];
	        for (int j = 0; j < i * N; j++) {
	            wins[j] = 0.54 - 0.46 * (Math.cos(2 * Math.PI * j / (i * N)));
	        }
	        return wins;
	    }
	
	
	    /**
	     * 短时能量
	     */
	    public static void shortTimeEnergy() {
	    }
	
	    /**
	     * 计算卷积
	     *
	     * @param self  数据段
	     * @param other 窗函数 （默认窗函数的长度远小于数据长度）
	     * @return
	     */
	    public static double[] conv(double[] self, double[] other) {
	        double[] result = new double[self.length + other.length - 1];
	        double current = 0;
	        for (int i = 0; i < self.length + other.length - 1; i++) {
	            current = 0;
	            for (int j = 0; j <= i; j++) {
	                if (j >= self.length || i - j >= other.length) {
	                    continue;
	                }
	                //TODO 去除一些数据的运算提高效率
	
	                current += self[j] * other[i - j];
	            }
	            result[i] = current;
	        }
	        return result;
	    }
	
	    /**
	     * 计算余弦距离 dot(En_compare, En_standard)/(norm(En_compare)*norm(En_standard))
	     *
	     * @param standard
	     * @param comapre
	     * @return
	     */
	    public static double cosineDistance(double[] standard, double[] comapre) {
	        double dot = 0;
	        double normStandard = 0;
	        double normCompare = 0;
	        for (int i = 0; i < standard.length; i++) {
	            dot += standard[i] * comapre[i];
	            normStandard += standard[i] * standard[i];
	            normCompare += comapre[i] * comapre[i];
	        }
	        double distance = dot / (Math.sqrt(normStandard) * Math.sqrt(normCompare));
	        return distance;
	    }
	
	    /**
	     * 通过阈值得到音频有效数据开始的下标
	     */
	    public static int findDataStartIndex(double[] audioData) {
	        for (int i = 0; i < audioData.length; i++) {
	            if (audioData[i] > DATA_START_VALUE) {
	                return i;
	            }
	        }
	        return -1;
	    }
	
	    /**
	     * 通过阈值得到音频有效数据结束的下标
	     */
	    public static int findDataEndIndex(double[] audioData) {
	        for (int i = audioData.length - 1; i >= 0; i--) {
	            if (audioData[i] > DATA_END_VALUE) {
	                return i;
	            }
	        }
	        return -1;
	    }
	
	    /**
	     * 截取音频有效数据（通过阈值获得的数据前后开始结束的下标来截取数据）
	     *
	     * @param audioData
	     * @return
	     */
	    public static double[] getUsefulData(double[] audioData, int start, int end) {
	        double[] usefulData = new double[end - start];
	        for (int i = start; i < end; i++) {
	            usefulData[i - start] = audioData[i];
	        }
	        return usefulData;
	    }
	
	    /**
	     * 截取音频有效数据（通过阈值获得的数据前后开始结束的下标来截取数据）
	     *
	     * @param audioData
	     * @return
	     */
	    public static double[] getUsefulData(double[] audioData) {
	        int start = AudioDataOperate.findDataStartIndex(audioData);
	        int end = AudioDataOperate.findDataEndIndex(audioData);
	        System.out.println("dataLength   " + audioData.length + "     getUsefulData    " + "start: " + start + "   end : " + end);
	        return getUsefulData(audioData, start, end);
	    }
	
	    /**
	     * 处理对比音频使其与标准音频长度相同（通过阈值获得的数据开始下标截取与标准音频相同长度的音频数据）
	     *
	     * @param audioData
	     * @return
	     */
	    public static double[] dealCompareData(double[] audioData, int start, int length) {
	        double[] usefulData = new double[length];
	        for (int i = start; i < start + length; i++) {
	            //从有效音频开始点截取标准音频的长度的音频可能超过对比音频长度边界
	            if (i >= audioData.length) {
	                usefulData[i - start] = 0;
	            } else {
	                usefulData[i - start] = audioData[i];
	            }
	        }
	        return usefulData;
	    }
	
	    /**
	     * 处理对比音频使其与标准音频长度相同（通过阈值获得的数据开始下标截取与标准音频相同长度的音频数据）
	     *
	     * @param audioData
	     * @return
	     */
	    public static double[] dealCompareData(double[] audioData, int length) {
	        int start = AudioDataOperate.findDataStartIndex(audioData);
	        System.out.println("dealCompareData: " + audioData.length + "   " + start + "   " + length);
	        return dealCompareData(audioData, start, length);
	    }
	
	    /**
	     * 滤波（差分方程）
	     *
	     * @param audioData
	     */
	    public static double[] filter(double[] audioData, double b0, double b1) {
	        double[] result = new double[audioData.length];
	        result[0] = audioData[0];
	        for (int i = 1; i < audioData.length; i++) {
	            result[i] = b0 * audioData[i] + b1 * audioData[i - 1];
	        }
	        return result;
	    }
	}
 
##遇到的问题
 1. MATLAB、Audacity导入音频原始数据时文件的大尾端、小尾端问题
 
##改进内容：
 1. 优化短时能量，卷积计算过程，提高计算效率
 2. 改进滤波方法
 ##项目截图
 
 ##项目地址
 https://github.com/xdyuchen/AudioScore

搬运自https://zhuanlan.zhihu.com/p/43396514
 
1、余弦函数
 
余弦函数在三角形中的计算公式
 
 在直角坐标系中
 
 
 向量a和向量b之间的距离我们用向量c表示，就是上图中的黄色直线，那么向量c在直角坐标系中的长度为
 
 将a，b，c带入三角函数的公式中得到如下的公式：
 
 这是2维空间中余弦函数的公式，那么多维空间余弦函数的公式就是：
 
2、余弦相似度
 
余弦相似度量：计算个体间的相似度。
 相似度越小，距离越大。相似度越大，距离越小。
 
余弦相似度算法：一个向量空间中两个向量夹角间的余弦值作为衡量两个个体之间差异的大小，余弦值接近1，夹角趋于0，表明两个向量越相似，余弦值接近于0，夹角趋于90度，表明两个向量越不相似。
 
下面我们介绍使用余弦相似度计算两段文本的相似度。思路：1、分词；2、列出所有词；3、分词编码；4、词频向量化；5、套用余弦函数计量两个句子的相似度。
 
句子A：这只皮靴号码大了。那只号码合适。
 
句子B：这只皮靴号码不小，那只更合适。
 
1、分词：使用结巴分词对上面两个句子分词后，分别得到两个列表：
 
listA=[‘这‘, ‘只‘, ‘皮靴‘, ‘号码‘, ‘大‘, ‘了‘, ‘那‘, ‘只‘, ‘号码‘, ‘合适‘]
 
listB=[‘这‘, ‘只‘, ‘皮靴‘, ‘号码‘, ‘不小‘, ‘那‘, ‘只‘, ‘更合‘, ‘合适‘]
 
2、列出所有词。将listA和listB放在一个set中，得到：
 
set={‘不小’, ‘了’, ‘合适’, ‘那’, ‘只’, ‘皮靴’, ‘更合’, ‘号码’, ‘这’, ‘大’}
 
将上述set转换为dict，key为set中的词，value为set中词出现的位置，即‘这’:1这样的形式。
 
dict1={‘不小’: 0, ‘了’: 1, ‘合适’: 2, ‘那’: 3, ‘只’: 4, ‘皮靴’: 5, ‘更合’: 6, ‘号码’: 7, ‘这’: 8, ‘大’: 9}，可以看出“不小”这个词在set中排第1，下标为0。
 
3、将listA和listB进行编码。将每个字转换为出现在set中的位置，转换后为：
 
listAcode=[8, 4, 5, 7, 9, 1, 3, 4, 7, 2]
 
listBcode=[8, 4, 5, 7, 0, 3, 4, 6, 2]
 
我们来分析listAcode，结合dict1，可以看到8对应的字是“这”，4对应的字是“只”，9对应的字是“大”，就是句子A和句子B转换为用数字来表示。
 
4、对listAcode和listBcode进行oneHot编码。就是计算每个分词出现的次数。oneHot编号后得到的结果如下：
 
listAcodeOneHot = [0, 1, 1, 1, 2, 1, 0, 2, 1, 1]
 
listBcodeOneHot = [1, 0, 1, 1, 2, 1, 1, 1, 1, 0]
 
下图总结了句子从分词，列出所有词，对分词进行编码，计算词频的过程
 
 5、得出两个句子的词频向量之后，就变成了计算两个向量之间夹角的余弦值，值越大相似度越高。
 
listAcodeOneHot = [0, 1, 1, 1, 2, 1, 0, 2, 1, 1]
 listBcodeOneHot = [1, 0, 1, 1, 2, 1, 1, 1, 1, 0]
 
 代码如下：
 
// An highlighted block
import jieba
import math
s1 = '这只皮靴号码大了。那只号码合适'
s1_cut = [i for i in jieba.cut(s1, cut_all=True) if i != '']
s2 = '这只皮靴号码不小，那只更合适'
s2_cut = [i for i in jieba.cut(s2, cut_all=True) if i != '']
print(s1_cut)
print(s2_cut)
word_set = set(s1_cut).union(set(s2_cut))
print(word_set)

word_dict = dict()
i = 0
for word in word_set:
    word_dict[word] = i
    i += 1
print(word_dict)

s1_cut_code = [word_dict[word] for word in s1_cut]
print(s1_cut_code)
s1_cut_code = [0]*len(word_dict)

for word in s1_cut:
    s1_cut_code[word_dict[word]]+=1
print(s1_cut_code)

s2_cut_code = [word_dict[word] for word in s2_cut]
print(s2_cut_code)
s2_cut_code = [0]*len(word_dict)
for word in s2_cut:
    s2_cut_code[word_dict[word]]+=1
print(s2_cut_code)

# 计算余弦相似度
sum = 0
sq1 = 0
sq2 = 0
for i in range(len(s1_cut_code)):
	sum += s1_cut_code[i] * s2_cut_code[i]
	sq1 += pow(s1_cut_code[i], 2)
	sq2 += pow(s2_cut_code[i], 2)

try:
	result = round(float(sum) / (math.sqrt(sq1) * math.sqrt(sq2)), 2)
except ZeroDivisionError:
    result = 0.0
print(result)

余弦相似度用向量空间中两向量夹角的余弦值作为衡量两个个体之间差异的大小。余弦值越接近1，表明两个向量的夹角越接近0度，则两个向量越相似。
 
我们把两个向量，向量a和向量b的夹角叫做θ，那么根据余弦定理可得
 
 
在二维空间中如果有两个向量，向量a(x1,y1)，向量b(x2,y2)，根据点积定义方式可得
 
 
 
此计算公式不局限与维度，即余弦的这种计算方法对n维向量也成立。在n维空间中如果有两个向量，向量a(a1,a2,a3,....,an)，向量b(b1,b2,b3,....bn)，根据点积公式可得
 
 
 
 
tips：百度百科里解释点积这个名词时，说到点积的几何定义方式的公式只对二维和三维空间有效，这是不对的。