natural 0.5.4 → 0.6.1

package/lib/natural/brill_pos_tagger/lib/TF_Parser.js

@@ -43,40 +43,51 @@ module.exports = (function() {
           }
           return(result);
         },
-        peg$c3 = null,
-        peg$c4 = function(c1, c2, pred, par1, par2) {
+        peg$c3 = function(c1, c2, pred, pars) {
+          var result = null;
+
           // Construct rule
-          var result = new TransformationRule(c1, c2, pred, par1, par2);
+          if (pars.length === 1) {
+            result = new TransformationRule(c1, c2, pred, pars[0]);
+          }
+          else {
+            if (pars.length === 2) {
+              result = new TransformationRule(c1, c2, pred, pars[0], pars[1]);
+            }
+            else {
+              result = new TransformationRule(c1, c2, pred);
+            }
+          }
           return(result);
         },
-        peg$c5 = /^[a-zA-Z_0-9_\-.,()]/,
-        peg$c6 = { type: "class", value: "[a-zA-Z_0-9_\\-.,()]", description: "[a-zA-Z_0-9_\\-.,()]" },
-        peg$c7 = function(characters) {
+        peg$c4 = /^[!-~\xA1-\xFF]/,
+        peg$c5 = { type: "class", value: "[!-~\\xA1-\\xFF]", description: "[!-~\\xA1-\\xFF]" },
+        peg$c6 = function(characters) {
            var s = "";
            for (var i = 0; i < characters.length; i++) {
              s += characters[i];
            }
            return(s);
           },
-        peg$c8 = "*",
-        peg$c9 = { type: "literal", value: "*", description: "\"*\"" },
-        peg$c10 = function(wc) {
+        peg$c7 = "*",
+        peg$c8 = { type: "literal", value: "*", description: "\"*\"" },
+        peg$c9 = function(wc) {
            return(wc)
           },
-        peg$c11 = "\r\n",
-        peg$c12 = { type: "literal", value: "\r\n", description: "\"\\r\\n\"" },
-        peg$c13 = "\n",
-        peg$c14 = { type: "literal", value: "\n", description: "\"\\n\"" },
-        peg$c15 = "\r",
-        peg$c16 = { type: "literal", value: "\r", description: "\"\\r\"" },
-        peg$c17 = "//",
-        peg$c18 = { type: "literal", value: "//", description: "\"//\"" },
-        peg$c19 = void 0,
-        peg$c20 = { type: "any", description: "any character" },
-        peg$c21 = " ",
-        peg$c22 = { type: "literal", value: " ", description: "\" \"" },
-        peg$c23 = "\t",
-        peg$c24 = { type: "literal", value: "\t", description: "\"\\t\"" },
+        peg$c10 = "\r\n",
+        peg$c11 = { type: "literal", value: "\r\n", description: "\"\\r\\n\"" },
+        peg$c12 = "\n",
+        peg$c13 = { type: "literal", value: "\n", description: "\"\\n\"" },
+        peg$c14 = "\r",
+        peg$c15 = { type: "literal", value: "\r", description: "\"\\r\"" },
+        peg$c16 = "//",
+        peg$c17 = { type: "literal", value: "//", description: "\"//\"" },
+        peg$c18 = void 0,
+        peg$c19 = { type: "any", description: "any character" },
+        peg$c20 = " ",
+        peg$c21 = { type: "literal", value: " ", description: "\" \"" },
+        peg$c22 = "\t",
+        peg$c23 = { type: "literal", value: "\t", description: "\"\\t\"" },
 
         peg$currPos          = 0,
         peg$reportedPos      = 0,
@@ -317,20 +328,16 @@ module.exports = (function() {
         if (s2 !== peg$FAILED) {
           s3 = peg$parseidentifier();
           if (s3 !== peg$FAILED) {
-            s4 = peg$parseidentifier();
-            if (s4 !== peg$FAILED) {
+            s4 = [];
+            s5 = peg$parseidentifier();
+            while (s5 !== peg$FAILED) {
+              s4.push(s5);
               s5 = peg$parseidentifier();
-              if (s5 === peg$FAILED) {
-                s5 = peg$c3;
-              }
-              if (s5 !== peg$FAILED) {
-                peg$reportedPos = s0;
-                s1 = peg$c4(s1, s2, s3, s4, s5);
-                s0 = s1;
-              } else {
-                peg$currPos = s0;
-                s0 = peg$c1;
-              }
+            }
+            if (s4 !== peg$FAILED) {
+              peg$reportedPos = s0;
+              s1 = peg$c3(s1, s2, s3, s4);
+              s0 = s1;
             } else {
               peg$currPos = s0;
               s0 = peg$c1;
@@ -367,22 +374,22 @@ module.exports = (function() {
 
       s0 = peg$currPos;
       s1 = [];
-      if (peg$c5.test(input.charAt(peg$currPos))) {
+      if (peg$c4.test(input.charAt(peg$currPos))) {
         s2 = input.charAt(peg$currPos);
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$c6); }
+        if (peg$silentFails === 0) { peg$fail(peg$c5); }
       }
       if (s2 !== peg$FAILED) {
         while (s2 !== peg$FAILED) {
           s1.push(s2);
-          if (peg$c5.test(input.charAt(peg$currPos))) {
+          if (peg$c4.test(input.charAt(peg$currPos))) {
             s2 = input.charAt(peg$currPos);
             peg$currPos++;
           } else {
             s2 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$c6); }
+            if (peg$silentFails === 0) { peg$fail(peg$c5); }
           }
         }
       } else {
@@ -392,7 +399,7 @@ module.exports = (function() {
         s2 = peg$parseS_no_eol();
         if (s2 !== peg$FAILED) {
           peg$reportedPos = s0;
-          s1 = peg$c7(s1);
+          s1 = peg$c6(s1);
           s0 = s1;
         } else {
           peg$currPos = s0;
@@ -411,17 +418,17 @@ module.exports = (function() {
 
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 42) {
-        s1 = peg$c8;
+        s1 = peg$c7;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$c9); }
+        if (peg$silentFails === 0) { peg$fail(peg$c8); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$parseS_no_eol();
         if (s2 !== peg$FAILED) {
           peg$reportedPos = s0;
-          s1 = peg$c10(s1);
+          s1 = peg$c9(s1);
           s0 = s1;
         } else {
           peg$currPos = s0;
@@ -438,28 +445,28 @@ module.exports = (function() {
     function peg$parseEOL() {
       var s0;
 
-      if (input.substr(peg$currPos, 2) === peg$c11) {
-        s0 = peg$c11;
+      if (input.substr(peg$currPos, 2) === peg$c10) {
+        s0 = peg$c10;
         peg$currPos += 2;
       } else {
         s0 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$c12); }
+        if (peg$silentFails === 0) { peg$fail(peg$c11); }
       }
       if (s0 === peg$FAILED) {
         if (input.charCodeAt(peg$currPos) === 10) {
-          s0 = peg$c13;
+          s0 = peg$c12;
           peg$currPos++;
         } else {
           s0 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$c14); }
+          if (peg$silentFails === 0) { peg$fail(peg$c13); }
         }
         if (s0 === peg$FAILED) {
           if (input.charCodeAt(peg$currPos) === 13) {
-            s0 = peg$c15;
+            s0 = peg$c14;
             peg$currPos++;
           } else {
             s0 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$c16); }
+            if (peg$silentFails === 0) { peg$fail(peg$c15); }
           }
         }
       }
@@ -471,12 +478,12 @@ module.exports = (function() {
       var s0, s1, s2, s3, s4, s5;
 
       s0 = peg$currPos;
-      if (input.substr(peg$currPos, 2) === peg$c17) {
-        s1 = peg$c17;
+      if (input.substr(peg$currPos, 2) === peg$c16) {
+        s1 = peg$c16;
         peg$currPos += 2;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$c18); }
+        if (peg$silentFails === 0) { peg$fail(peg$c17); }
       }
       if (s1 !== peg$FAILED) {
         s2 = [];
@@ -486,7 +493,7 @@ module.exports = (function() {
         s5 = peg$parseEOL();
         peg$silentFails--;
         if (s5 === peg$FAILED) {
-          s4 = peg$c19;
+          s4 = peg$c18;
         } else {
           peg$currPos = s4;
           s4 = peg$c1;
@@ -497,7 +504,7 @@ module.exports = (function() {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$c20); }
+            if (peg$silentFails === 0) { peg$fail(peg$c19); }
           }
           if (s5 !== peg$FAILED) {
             s4 = [s4, s5];
@@ -518,7 +525,7 @@ module.exports = (function() {
           s5 = peg$parseEOL();
           peg$silentFails--;
           if (s5 === peg$FAILED) {
-            s4 = peg$c19;
+            s4 = peg$c18;
           } else {
             peg$currPos = s4;
             s4 = peg$c1;
@@ -529,7 +536,7 @@ module.exports = (function() {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$c20); }
+              if (peg$silentFails === 0) { peg$fail(peg$c19); }
             }
             if (s5 !== peg$FAILED) {
               s4 = [s4, s5];
@@ -572,19 +579,19 @@ module.exports = (function() {
 
       s0 = [];
       if (input.charCodeAt(peg$currPos) === 32) {
-        s1 = peg$c21;
+        s1 = peg$c20;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$c22); }
+        if (peg$silentFails === 0) { peg$fail(peg$c21); }
       }
       if (s1 === peg$FAILED) {
         if (input.charCodeAt(peg$currPos) === 9) {
-          s1 = peg$c23;
+          s1 = peg$c22;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$c24); }
+          if (peg$silentFails === 0) { peg$fail(peg$c23); }
         }
         if (s1 === peg$FAILED) {
           s1 = peg$parseEOL();
@@ -596,19 +603,19 @@ module.exports = (function() {
       while (s1 !== peg$FAILED) {
         s0.push(s1);
         if (input.charCodeAt(peg$currPos) === 32) {
-          s1 = peg$c21;
+          s1 = peg$c20;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$c22); }
+          if (peg$silentFails === 0) { peg$fail(peg$c21); }
         }
         if (s1 === peg$FAILED) {
           if (input.charCodeAt(peg$currPos) === 9) {
-            s1 = peg$c23;
+            s1 = peg$c22;
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$c24); }
+            if (peg$silentFails === 0) { peg$fail(peg$c23); }
           }
           if (s1 === peg$FAILED) {
             s1 = peg$parseEOL();
@@ -627,19 +634,19 @@ module.exports = (function() {
 
       s0 = [];
       if (input.charCodeAt(peg$currPos) === 32) {
-        s1 = peg$c21;
+        s1 = peg$c20;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$c22); }
+        if (peg$silentFails === 0) { peg$fail(peg$c21); }
       }
       if (s1 === peg$FAILED) {
         if (input.charCodeAt(peg$currPos) === 9) {
-          s1 = peg$c23;
+          s1 = peg$c22;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$c24); }
+          if (peg$silentFails === 0) { peg$fail(peg$c23); }
         }
         if (s1 === peg$FAILED) {
           s1 = peg$parseComment();
@@ -648,19 +655,19 @@ module.exports = (function() {
       while (s1 !== peg$FAILED) {
         s0.push(s1);
         if (input.charCodeAt(peg$currPos) === 32) {
-          s1 = peg$c21;
+          s1 = peg$c20;
           peg$currPos++;
         } else {
           s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$c22); }
+          if (peg$silentFails === 0) { peg$fail(peg$c21); }
         }
         if (s1 === peg$FAILED) {
           if (input.charCodeAt(peg$currPos) === 9) {
-            s1 = peg$c23;
+            s1 = peg$c22;
             peg$currPos++;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$c24); }
+            if (peg$silentFails === 0) { peg$fail(peg$c23); }
           }
           if (s1 === peg$FAILED) {
             s1 = peg$parseComment();
@@ -681,11 +688,11 @@ module.exports = (function() {
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$c20); }
+        if (peg$silentFails === 0) { peg$fail(peg$c19); }
       }
       peg$silentFails--;
       if (s1 === peg$FAILED) {
-        s0 = peg$c19;
+        s0 = peg$c18;
       } else {
         peg$currPos = s0;
         s0 = peg$c1;

package/lib/natural/brill_pos_tagger/lib/TF_Parser.pegjs

@@ -13,10 +13,22 @@ transformation_rules = rules: (S transformation_rule S) +
   return(result);
 }
 
-transformation_rule = c1: category1 c2: category2 pred: predicate par1: parameter par2: parameter ?
+transformation_rule = c1: category1 c2: category2 pred: predicate pars: parameter *
 {
+  var result = null;
+
   // Construct rule
-  var result = new TransformationRule(c1, c2, pred, par1, par2);
+  if (pars.length === 1) {
+    result = new TransformationRule(c1, c2, pred, pars[0]);
+  }
+  else {
+    if (pars.length === 2) {
+      result = new TransformationRule(c1, c2, pred, pars[0], pars[1]);
+    }
+    else {
+      result = new TransformationRule(c1, c2, pred);
+    }
+  }
   return(result);
 }
 
@@ -29,7 +41,10 @@ predicate = identifier
 parameter = identifier
 
 identifier =
-  characters: [a-zA-Z_0-9_\-\.,()]+ S_no_eol
+//  characters: [a-zA-Z_0-9_\-\.,()]+ S_no_eol
+// https://en.wikipedia.org/wiki/List_of_Unicode_characters
+// Ranges supported: U+0021	- U+007E plus U+00A1 - U+00FF
+  characters: [!-~¡-ÿ]+ S_no_eol
   {
    var s = "";
    for (var i = 0; i < characters.length; i++) {
@@ -52,5 +67,5 @@ S =
   (' ' / '\t' / EOL / Comment)*
 S_no_eol =
   (' ' / '\t' / Comment)*
-EOI= 
+EOI=
   !.

package/lib/natural/brill_pos_tagger/lib/TransformationRule.js

@@ -20,6 +20,7 @@
 //var logger = log4js.getLogger();
 
 var Predicate = require("./Predicate");
+var Sentence = require('./Sentence');
 
 //logger.setLevel('INFO');
 
@@ -42,11 +43,11 @@ TransformationRule.prototype.key = function() {
   return(this.literal.toString());
 };
 
-TransformationRule.prototype.apply = function(tagged_sentence, position) {
-  if ((tagged_sentence[position][1] === this.old_category) ||
+TransformationRule.prototype.apply = function(sentence, position) {
+  if ((sentence.taggedWords[position].tag === this.old_category) ||
       (this.old_category === category_wild_card)) {
-    if (this.predicate.evaluate(tagged_sentence, position)) {
-      tagged_sentence[position][1] = this.new_category;
+    if (this.predicate.evaluate(sentence, position)) {
+      sentence.taggedWords[position].tag = this.new_category;
       //logger.debug('TransformationRule.apply: changed category ' +
         //this.old_category + ' to ' + this.new_category +
         //' at position ' + position);
@@ -62,13 +63,13 @@ TransformationRule.prototype.apply = function(tagged_sentence, position) {
 // category to newTag
 TransformationRule.prototype.isApplicableAt = function(sentence, taggedSentence, i) {
   //logger.debug("TransformationRule.prototype.isApplicableAt: " + taggedSentence);
-  var applies = (taggedSentence[i][1] === this.old_category) &&
+  var applies = (taggedSentence.taggedWords[i].tag === this.old_category) &&
     this.predicate.evaluate(taggedSentence, i);
   //logger.debug("TransformationRule.prototype.isApplicableAt: " + applies);
 
   // Set newTag to let the trainer know what the new tag would become
   if (applies) {
-    sentence[i].newTag = this.new_category;
+    sentence.taggedWords[i].newTag = this.new_category;
   }
   return(applies);
 };
@@ -92,16 +93,14 @@ TransformationRule.prototype.prettyPrint = function() {
 
 // Applies the rule the given location (if it applies)
 TransformationRule.prototype.applyAt = function(sentence, i) {
-  var taggedSentence = sentence.map(function(token) {
-    return [token.token, token.tag];
-  });
+  var taggedSentence = sentence.clone();
 
   //logger.debug("TransformationRule.prototype.applyAt: input sentence length: " + sentence.length);
   //logger.debug("TransformationRule.prototype.applyAt: tagged sentence length: " + taggedSentence.length);
 
-  this.apply(taggedSentence, i);
+  this.apply(sentence, i);
   // Assign the new tag to the corpus site
-  sentence[i].testTag = taggedSentence[i][1];
+  sentence.taggedWords[i].testTag = taggedSentence.taggedWords[i].tag;
 };
 
 // Calculate the net score of this rule

package/lib/natural/classifiers/classifier.js

@@ -58,7 +58,7 @@ function addDocument(text, classification) {
     }
 
     if(typeof text === 'string')
-	text = this.stemmer.tokenizeAndStem(text);
+	text = this.stemmer.tokenizeAndStem(text, this.keepStops);
 
     if(text.length === 0) {
         // ignore empty documents
@@ -82,7 +82,7 @@ function removeDocument(text, classification) {
     , pos;
 
   if (typeof text === 'string') {
-    text = this.stemmer.tokenizeAndStem(text);
+    text = this.stemmer.tokenizeAndStem(text, this.keepStops);
   }
 
   for (var i = 0, ii = docs.length; i < ii; i++) {
@@ -107,7 +107,7 @@ function textToFeatures(observation) {
     var features = [];
 
     if(typeof observation === 'string')
-	observation = this.stemmer.tokenizeAndStem(observation);
+	observation = this.stemmer.tokenizeAndStem(observation, this.keepStops);
 
     for(var feature in this.features) {
         if(observation.indexOf(feature) > -1)
@@ -180,7 +180,7 @@ function trainParallel(numThreads, callback) {
     for (var i = this.lastAdded; i < totalDocs; i++) {
         var observation = this.docs[i].text;
         if (typeof observation === 'string')
-            observation = this.stemmer.tokenizeAndStem(observation);
+            observation = this.stemmer.tokenizeAndStem(observation, this.keepStops);
         obsDocs.push({
             index: i,
             observation: observation
@@ -289,7 +289,7 @@ function trainParallelBatches(options) {
     for (var i = this.lastAdded; i < totalDocs; i++) {
         var observation = this.docs[i].text;
         if (typeof observation === 'string')
-            observation = this.stemmer.tokenizeAndStem(observation);
+            observation = this.stemmer.tokenizeAndStem(observation, this.keepStops);
         obsDocs.push({
             index: i,
             observation: observation
@@ -437,17 +437,24 @@ function load(filename, callback) {
     });
 }
 
+function setOptions(options){
+    this.keepStops = (options.keepStops) ? true : false;
+}
+
 Classifier.prototype.addDocument = addDocument;
 Classifier.prototype.removeDocument = removeDocument;
 Classifier.prototype.train = train;
-Classifier.prototype.trainParallel = trainParallel;
-Classifier.prototype.trainParallelBatches = trainParallelBatches;
+if (Threads) {
+  Classifier.prototype.trainParallel = trainParallel;
+  Classifier.prototype.trainParallelBatches = trainParallelBatches;
+  Classifier.prototype.retrainParallel = retrainParallel;
+}
 Classifier.prototype.retrain = retrain;
-Classifier.prototype.retrainParallel = retrainParallel;
 Classifier.prototype.classify = classify;
 Classifier.prototype.textToFeatures = textToFeatures;
 Classifier.prototype.save = save;
 Classifier.prototype.getClassifications = getClassifications;
+Classifier.prototype.setOptions = setOptions;
 Classifier.restore = restore;
 Classifier.load = load;
 

package/lib/natural/classifiers/maxent/Classifier.js

@@ -0,0 +1,125 @@
+/*
+    Classifier class that provides functionality for training and
+    classification
+    Copyright (C) 2017 Hugo W.L. ter Doest
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+var fs = require('fs');
+
+var Context = require('./Context');
+var Element = require('./Element');
+var Sample = require('./Sample');
+var Scaler = require('./GISScaler');
+var FeatureSet = require('./FeatureSet');
+
+function Classifier(features, sample) {
+  if (features) {
+    this.features = features;
+  }
+  else {
+    this.features = new featureSet();
+  }
+  this.features = features;
+  if (sample) {
+    this.sample = sample;
+  }
+  else {
+    this.sample = new Sample();
+  }
+}
+
+// Loads a classifier from file.
+// Caveat: feature functions are generated from the sample elements. You need
+// to create your own specialisation of the Element class that can generate
+// your own specific feature functions
+Classifier.prototype.load = function(filename, elementClass, callback) {
+  fs.readFile(filename, 'utf8', function(err, data) {
+
+    if(!err) {
+        classifierData = JSON.parse(data);
+        var sample = new Sample();
+        classifierData.sample.elements.forEach(function(elementData) {
+          var elt = new elementClass(elementData.a, new Context(elementData.b.data));
+          sample.addElement(elt);
+        });
+        var featureSet = new FeatureSet();
+        sample.generateFeatures(featureSet);
+        var classifier = new Classifier(featureSet, sample);
+        callback(err, classifier);
+    }
+    else {
+      if(callback) {
+        callback(err);
+      }
+    }
+  });
+};
+
+Classifier.prototype.save = function(filename, callback) {
+  var data = JSON.stringify(this, null, 2);
+  var classifier = this;
+  fs.writeFile(filename, data, 'utf8', function(err) {
+      if(callback) {
+          callback(err, err ? null : classifier);
+      }
+  });
+};
+
+Classifier.prototype.addElement = function(x) {
+  this.sample.addElement(x);
+};
+
+Classifier.prototype.addDocument = function(context, classification, elementClass) {
+  Classifier.prototype.addElement(new elementClass(classification, context));
+};
+
+Classifier.prototype.train = function(maxIterations, minImprovement, approxExpectation) {
+  this.scaler = new Scaler(this.features, this.sample);
+  this.p = this.scaler.run(maxIterations, minImprovement, approxExpectation);
+};
+
+Classifier.prototype.getClassifications = function(b) {
+  var scores = [];
+  var that = this;
+  this.sample.getClasses().forEach(function(a) {
+    var x = new Element(a, b);
+    scores.push({
+      "label": a,
+      "value": that.p.calculateAPriori(x)
+    });
+  });
+  return scores;
+};
+
+Classifier.prototype.classify = function(b) {
+  var scores = this.getClassifications(b);
+  // Sort the scores in an array
+  scores.sort(function(a, b) {
+    return b.value - a.value;
+  });
+  // Check if the classifier discriminates
+  var min = scores[scores.length - 1].value;
+  var max = scores[0].value;
+  if (min === max) {
+      return "";
+  }
+  else {
+    // Return the highest scoring classes
+    return scores[0].label;
+  }
+};
+
+module.exports = Classifier;