JavaScript Pattern Comparison

Question

I'm working on a small machine learning theoretical algorithm using nodeJs. My goal is to compare many array patterns to one source pattern then return how similar they are represented as a percent . For an example pattern1 maybe 80% similar to the source pattern .

What can be the best method for determining percent similarity for one array to another?

What I've done so far..

//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]

Since I've chosen a percent based outcome , I figured I should base my source pattern off percentage change from first value to second value in array .

 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;
    }

Here I will generate my source pattern from my source sequence

       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);

Now I will create more patterns to be compared

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

Below is my comparison function

 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;
}

Now I can try to estimate the similarity

var similarityOfTest1 = processPattern(sourcePattern , testPattern1)

My problem is that this only works on sequences within the same range of value .. for example 0.50 , 0.52 .. the percent change in these values would not be the same for 0.20 , 0.22 but the value difference is the same ie -> 0.02

I thought about a difference in value based pattern but at this point I'm lost.

All answers will be considered . Thanks for the help!

Answer 1

used reduce to get the difference than the average.

//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

In my experience, the similarity of two vectors (arrays) is measured using the dot product ex. Like it says in that link, you multiply each corresponding elements of the arrays, add those up, then divide by the magnitude of each array (square root of the sum of the squares of each component). Rosetta Code has an example of the dot product in JavaScript, copied here

// 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]));
}

So, you would call

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

And whichever is bigger is the closer sequence to sourceSequence.

Answer 3

I'm not sure you need machine learning for this. You have a source pattern and you have some inputs and you basically want to perform a diff of the patterns.

Machine learning could be used to find the patterns, assuming you have some heuristic for measuring the error (if you're using unsupervised learning techniques) or you have sample sets to train the network.

But if you are simply wanting to measure the differences between one pattern and another pattern then just perform a diff operation. What you'll need to do is decide what differences your measuring and how to normalize the result.

Answer 4

I can't tell how exactly you would like to measure the similarity. I go by calculating the difference of corresponding items and accumulating these differences to see how much deviation it would result from the sum of the source array. You can play with the calculation the way you like.

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));