NaN returns when first training entry is longer then second

[markg85]

Hi,

My first steps in deep learning don't go so well. I keep getting NaN.
That turned out to be a "lucky" coincidence.

See this full example:

const Mind = require('node-mind');

var asciiToBin = (function () {
    var pad = '00000000';

    return function (str) {
        return str.replace(/./g, function (c) {
            var bin = c.charCodeAt(0).toString(2);
            return pad.substring(bin.length) + bin;
        });
    };
}());

var binToAscii = function (bin) {
    return bin.replace(/[01]{8}/g, function (v) {
        return String.fromCharCode(parseInt(v, 2));
    });
};

function binArray(data) {
  return Array.from(asciiToBin(data)).map(Number);
}

const mind = new Mind()
.learn([
  { input: binArray("the2"), output: [1] },
  { input: binArray("the"), output: [1] }
]);

const result = mind.predict(binArray("the"));

console.log(result);

That returns NaN.
Now if i merely swap the learn inputs around to this:

  { input: binArray("the"), output: [1] },
  { input: binArray("the2"), output: [1] }

Then it magically starts working :)

This is not the only ones where it produces NaN. It does so in the following cases as well (only changing the inputs, not the predict):

  { input: binArray("the "), output: [1] },
  { input: binArray("the "), output: [1] }

Here it seems like the predict has to be at least as long as the shortest input.

  { input: binArray("one"), output: [1] },
  { input: binArray("two"), output: [1] },
  { input: binArray("a"), output: [1] },

Also gives NaN. Puttin "a" on top makes it work (in this case).

This might be a bug, and one that seems rather easy to get? Or i'm doing something else extremely wrong, in which case i'd also love to hear that!

p.s. if one knows a more efficient way to convert a string to a binary array. Or if there is a more elegant way of thing this in this library, please do tell :)

Cheers,
Mark

[markg85]

Hmm, what i said above is still very much true, but it's true for any case where n+1 is shorter then n. N being the entry you attempt to learn.

That basically means that you can only learn entries of equal length or where the length is bigger than the last entry you learned.