JavaScript模式比较

Question

我正在研究一个使用nodeJs的小型机器学习理论算法。 我的目标是比较许多阵列模式，以一个源模式然后返回如何 相似，他们表示为百分比。对于一个示例，pattern1可能与源模式有80％的相似性。

确定一个阵列与另一个阵列的百分比相似度的最佳方法是什么？

什么我迄今所做..

//source 
var soureSequence = [0.53,0.55,0.50,0.40,0.50,0.52,0.58,0.60] 

//patterns to compare 
var sequence1 = [0.53,0.54,0.49,0.40,0.50,0.52,0.58,0.60] 
var sequence2 = [0.53,0.55,0.50,0.42,0.50,0.53,0.57,0.62] 

既然我已经选择了一种基于％的结果，我想我应该从第一价值基础我的源图案关百分比变化第二数组中的值。

var percentChange = (firstVal, secondVal) => { 
     var pChange = ((parseFloat(secondVal) - firstVal)/
     Math.abs(firstVal)) * 100.00; 

     //To avoid NaN , Infinity , and Zero 

     if(!pChange || pChange == 0){ 
      return 0.00000001 
     } 
     return pChange; 
    } 

在这里，我会从我的源序列生成我的源模式

 var storePattern = function(sequence){ 
      var pattern = []; 
      for(var i = 0 ; i < sequence.length ; i++){ 
       let $change = percentChange(sequence[i] , sequence[i + 1]); 
       if(i != sequence.length && $change){ 
        pattern.push($change) 
       } 
      } 
    return pattern; 
    } 



    var sourcePattern = storePattern(soureSequence); 

现在，我将创造更多的模式进行比较

var testPattern1 = storePattern(sequence1); 
    var testPattern2 = storePattern(sequence2); 

下面是我的比较功能

var processPattern = function(source , target){ 
    var simularityArray = []; 

    for(var i = 0 ; i < target.length ; i++){ 
     //Compare percent change at indexof testPattern to sourcePattern of same index 
     let change = Math.abs(percentChange(target[i] , source[i])); 
     simularityArray.push(100.00 - change); 
    } 

    var rating = simularityArray.reduce((a,b) => { 
     return a + b 
    }); 

    //returns percent rating based of average of similarity pattern 

    rating = rating/parseFloat(source.length + ".00"); 
    return rating; 
} 

现在我可以尝试估计相似

var similarityOfTest1 = processPattern(sourcePattern , testPattern1) 

我的问题是同一范围内的值 ..内的序列这只适用于例如0.50，0.52 ..这些值的百分比变化将不会是相同的0.20，0.22但价值差异是相同的，即 - > 0.02

我想到价值差异模式，但在这一点上，我迷路了。

将考虑所有答案。谢谢您的帮助！

Answer 1

使用减少得到的差异比平均。

//patterns to compare 
 
var sequence1 = [0.53,0.54,0.49,0.40,0.50,0.52,0.58,0.60] 
 
var sequence2 = [0.53,0.55,0.50,0.42,0.50,0.53,0.57,0.62] 
 

 
function diff(sequence){ 
 
var soureSequence = [0.53,0.55,0.50,0.40,0.50,0.52,0.58,0.60] 
 
    var delta = soureSequence.reduce(function (r, a, i, aa) { 
 
     i && r.push(a - sequence[i]); 
 
     return r; 
 
    }, []), 
 
    average = delta.reduce(function (a, b) { return a + b; })/delta.length; 
 
    
 
    return {delta:delta, average:average} 
 
} 
 
console.log('sequence1',diff(sequence1)); 
 
console.log('sequence2',diff(sequence2));

Answer 2

在我的经验，两个向量（阵列）的相似性是使用点积ex测量。就像它在该链接中所说的那样，将数组中的每个对应元素相乘，将它们相加，然后除以每个数组的大小（每个组成部分的平方和的平方根）。罗塞塔代码有dot product in JavaScript的一个例子，在这里复制

// dotProduct :: [Int] -> [Int] -> Int 
const dotProduct = (xs, ys) => { 
    const sum = xs => xs ? xs.reduce((a, b) => a + b, 0) : undefined; 

    return xs.length === ys.length ? (
     sum(zipWith((a, b) => a * b, xs, ys)) 
    ) : undefined; 
} 

// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] 
const zipWith = (f, xs, ys) => { 
    const ny = ys.length; 
    return (xs.length <= ny ? xs : xs.slice(0, ny)) 
     .map((x, i) => f(x, ys[i])); 
} 

所以，你会打电话

const score1 = dotProduct(sourceSequence, sequence1); 
const score2 = dotProduct(sourceSequence, sequence2); 

而且无论是大是sourceSequence越接近序列。

Answer 3

我不确定你需要机器学习。你有一个源模式，你有一些输入，你基本上想要执行模式的差异。

机器学习可以用来找到模式，假设你有一些启发式的测量错误（如果你使用无监督学习技术），或者你有样本集来训练网络。

但是，如果您只是想测量一个模式和另一个模式之间的差异，那么只需执行diff操作。你需要做的是决定你的测量和如何规范化结果有什么不同。

Answer 4

我无法确定您想如何衡量相似度。我通过计算相应项目的差异并累积这些差异来查看源数组总和会产生多少偏差。你可以用你喜欢的方式玩这个计算。

function check([x,...xs],[y,...ys], state = {sumSource: 0, sumDiff: 0}){ 
 
    state.sumSource += x; 
 
    state.sumDiff += Math.abs(x-y); 
 
    return xs.length ? check(xs,ys,state) : (100 - 100 * state.sumDiff/state.sumSource).toFixed(4) + "% similarity"; 
 
} 
 

 
var soureSequence = [0.53,0.55,0.50,0.40,0.50,0.52,0.58,0.60], 
 
    sequence1  = [0.53,0.54,0.49,0.40,0.50,0.52,0.58,0.60], 
 
    sequence2  = [0.53,0.55,0.50,0.42,0.50,0.53,0.57,0.62]; 
 

 
console.log(check(soureSequence,sequence1)); 
 
console.log(check(soureSequence,sequence2));