natural 0.5.6 → 0.6.3

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

@@ -444,10 +444,12 @@ function setOptions(options){
 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;

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;

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

@@ -0,0 +1,33 @@
+/*
+  Context class
+  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 stringify = require('json-stable-stringify');
+
+function Context(data) {
+  this.data = data;
+}
+
+// Create a predictable key string for looking up in a hash
+Context.prototype.toString = function() {
+  if (!this.key) {
+    this.key = stringify(this.data);
+  }
+  return this.key;
+};
+
+module.exports = Context;

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

@@ -0,0 +1,145 @@
+/*
+    Distribution class for probability distributions
+    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 Element = require('./Element');
+
+function Distribution(alpha, featureSet, sample) {
+  this.alpha = alpha;
+  this.featureSet = featureSet;
+  this.sample = sample;
+}
+
+// Returns the distribution as a string that can be stored for later usage
+Distribution.prototype.toString = function() {
+
+}
+
+Distribution.prototype.weight = function(x) {
+  var product = 1;
+  var that = this;
+
+  this.alpha.forEach(function(alpha_j, j) {
+    product *= Math.pow(alpha_j, that.featureSet.getFeatures()[j].apply(x));
+  });
+  return product;
+};
+
+Distribution.prototype.calculateAPriori = function(x) {
+  if (!this.aPriorisBeforeNormalisation[x.toString()]) {
+    this.aPriorisBeforeNormalisation[x.toString()] = this.weight(x);
+  }
+  return this.aPriorisBeforeNormalisation[x.toString()];// / this.aPrioriNormalisationConstant;
+};
+
+// Memoize a priori probabilities of sample elements
+Distribution.prototype.prepareWeights = function() {
+  this.aPriorisBeforeNormalisation = {};
+  this.aPrioriNormalisationConstant = 0;
+  var sum = 0;
+  var that = this;
+  this.sample.elements.forEach(function(x) {
+    that.aPriorisBeforeNormalisation[x.toString()] = that.weight(x);
+    sum += that.aPriorisBeforeNormalisation[x.toString()];
+  });
+  this.aPrioriNormalisationConstant = sum;
+};
+
+Distribution.prototype.calculateAPosteriori = function(x) {
+  if (!this.aPriorisBeforeNormalisation[x.toString()]) {
+    this.aPriorisBeforeNormalisation[x.toString()] = this.weight(x);
+  }
+  if (!this.aPosterioriNormalisationConstants[x.b.toString()]) {
+    this.aPosterioriNormalisationConstants[x.b.toString()] = this.aPosterioriNormalisation(x.b);
+  }
+  return this.aPriorisBeforeNormalisation[x] / this.aPosterioriNormalisationConstants[x.b.toString()];
+};
+
+Distribution.prototype.aPosterioriNormalisation = function(b) {
+  var sum = 0;
+
+  var that = this;
+  this.sample.getClasses().forEach(function(a) {
+    sum += that.weight(new Element(a, b));
+  });
+
+  return(sum);
+};
+
+// Memoize a posteriori probabilities of sample elements
+Distribution.prototype.prepareAPosterioris = function() {
+  this.aPosterioriNormalisationConstants = {};
+
+  var contextSeen = {};
+  var that = this;
+  this.sample.elements.forEach(function(sampleElement) {
+    var context = sampleElement.b;
+    if (!contextSeen[context]) {
+      contextSeen[context] = true;
+      that.aPosterioriNormalisationConstants[context] =
+        that.aPosterioriNormalisation(context);
+    }
+  });
+};
+
+// Memoize all probabilities of sample elements
+Distribution.prototype.prepare = function() {
+  this.prepareWeights();
+  //console.log("Weights prepared");
+  this.prepareAPosterioris();
+};
+
+// Relative entropy between observered distribution and derived distribution
+Distribution.prototype.KullbackLieblerDistance = function() {
+  var sum = 0;
+  var that = this;
+  this.sample.elements.forEach(function(x) {
+    sum += that.sample.observedProbability(x) * Math.log(that.sample.observedProbability(x) / that.calculateAPriori(x));
+  });
+  return sum;
+};
+
+Distribution.prototype.logLikelihood = function() {
+  var sum = 0;
+  var that = this;
+  this.sample.elements.forEach(function(x) {
+    sum += that.sample.observedProbability(x) * Math.log(that.calculateAPriori(x));
+  });
+  return sum;
+};
+
+Distribution.prototype.entropy = function() {
+  var sum = 0;
+  var that = this;
+  this.sample.elements.forEach(function(x) {
+    var p = that.calculateAPriori(x);
+    sum += p * Math.log(p);
+  });
+  return sum;
+};
+
+Distribution.prototype.checkSum = function() {
+  var sum = 0;
+  var that = this;
+  this.sample.elements.forEach(function(x) {
+      sum += that.calculateAPriori(x);
+  });
+  //console.log("Distribution.checkSum is " + sum);
+  return sum;
+}
+
+module.exports = Distribution;

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

@@ -0,0 +1,34 @@
+/*
+    Element class for elements in the event space
+    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 Feature = require('./Feature');
+
+// a is class and b is context
+function Element(a, b) {
+  this.a = a;
+  this.b = b;
+}
+
+Element.prototype.toString = function() {
+  if (!this.key) {
+    this.key =  this.a + this.b.toString();
+  }
+  return this.key;
+};
+
+module.exports = Element;

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

@@ -0,0 +1,88 @@
+/*
+    Feature class for features that fire (or don't) on combinations of context
+    and class
+    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/>.
+*/
+
+
+function Feature(f, name, parameters) {
+  this.evaluate = f;
+  this.name = name;
+  this.parameters = parameters;
+
+  var tmp = "";
+  parameters.forEach(function(par) {
+    tmp += par + "|";
+  });
+  this.parametersKey = tmp.substr(0, tmp.length - 1);
+}
+
+Feature.prototype.apply = function(x) {
+  return this.evaluate(x);
+};
+
+Feature.prototype.expectationApprox = function(p, sample) {
+  var totalSum = 0;
+  var that = this;
+  var sum = 0;
+  var seen = {};
+  var A = sample.getClasses();
+  sample.elements.forEach(function(sampleElement) {
+    var b_i = sampleElement.b;
+
+    if (!seen[b_i.toString()]) {
+      seen[b_i.toString()] = true;
+      var Element = require('./Element');
+
+      A.forEach(function(a) {
+        var x = new Element(a, b_i);
+        sum += sample.observedProbabilityOfContext(b_i) * p.calculateAPosteriori(x) * that.apply(x);
+      });
+    }
+  });
+  return sum;
+};
+
+// Diect calculation of expected value of this feature according to distribution p
+// In real-life applications with a lot of features this is not tractable
+Feature.prototype.expectation = function(p, A, B) {
+  var sum = 0;
+  var that = this;
+  A.forEach(function(a) {
+    B.forEach(function(b) {
+        var x = new Element(a, b);
+        sum += (p.calculateAPriori(x) * that.apply(x));
+    });
+  });
+  return sum;
+};
+
+// Observed expectation of this feature in the sample
+Feature.prototype.observedExpectation = function(sample) {
+  if (this.observedExpect) {
+    return this.observedExpect;
+  }
+  var N = sample.size();
+  var sum = 0;
+  var that = this;
+  sample.elements.forEach(function(x) {
+    sum += that.apply(x);
+  });
+  this.observedExpect = sum / N;
+  return this.observedExpect;
+};
+
+module.exports = Feature;

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

@@ -0,0 +1,67 @@
+/*
+  Feature set class for administrating a set of unique feature
+  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/>.
+*/
+
+
+function FeatureSet() {
+  this.features = [];
+  this.map = {};
+}
+
+// Returns true if the feature did not exist and was added
+FeatureSet.prototype.addFeature = function(feature) {
+  if (!this.featureExists(feature)) {
+    this.map[feature.name +" | " + feature.parametersKey] = true;
+    this.features.push(feature);
+    //console.log("FeatureSet.addFeature: feature added: " + feature.name + " - " + feature.parametersKey);
+    return true;
+  }
+  else {
+    return false;
+  }
+};
+
+FeatureSet.prototype.featureExists = function(feature) {
+  if (this.map[feature.name +" | " + feature.parametersKey]) {
+    //console.log("FeatureSet.featureExists: feature already exists: " +
+    //  feature.name + " - " + feature.parameters);
+    return true;
+  }
+  else {
+    return false;
+  }
+};
+
+// Returns an array of features
+// If the available array this.features is up to date it is returned immediately
+FeatureSet.prototype.getFeatures = function() {
+  return this.features;
+};
+
+FeatureSet.prototype.size = function() {
+  return this.features.length;
+};
+
+FeatureSet.prototype.prettyPrint = function() {
+  var s = "";
+  Object.keys(this.map).forEach(function(key) {
+    s += key + "\n";
+  });
+  return s;
+};
+
+module.exports = FeatureSet;