natural 6.10.2 → 6.10.3

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

@@ -1,6 +1,6 @@
 /*
-Feature set class for administrating a set of unique feature
-Copyright (C) 2017 Hugo W.L. ter Doest
+Feature set class for administrating a set of unique features
+Copyright (C) 2017, 2023 Hugo W.L. ter Doest
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,49 +23,51 @@ THE SOFTWARE.
 
 'use strict'
 
-function FeatureSet () {
-  this.features = []
-  this.map = {}
-}
+class FeatureSet {
+  constructor () {
+    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
+  // Returns true if the feature did not exist and was added
+  addFeature (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
+  featureExists (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
-}
+  // Returns an array of features
+  // If the available array this.features is up to date it is returned immediately
+  getFeatures () {
+    return this.features
+  }
 
-FeatureSet.prototype.size = function () {
-  return this.features.length
-}
+  size () {
+    return this.features.length
+  }
 
-FeatureSet.prototype.prettyPrint = function () {
-  let s = ''
-  Object.keys(this.map).forEach(function (key) {
-    s += key + '\n'
-  })
-  return s
+  prettyPrint () {
+    let s = ''
+    Object.keys(this.map).forEach(function (key) {
+      s += key + '\n'
+    })
+    return s
+  }
 }
 
 module.exports = FeatureSet

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

@@ -1,6 +1,6 @@
 /*
 GISScaler class that finds parameters of features
-Copyright (C) 2017 Hugo W.L. ter Doest
+Copyright (C) 2017, 2023 Hugo W.L. ter Doest
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -26,125 +26,126 @@ THE SOFTWARE.
 const Feature = require('./Feature')
 const Distribution = require('./Distribution')
 
-// classes is an array of classes
-// features is an array of feature functions
-function GISScaler (featureSet, sample) {
-  this.featureSet = featureSet
-  this.sample = sample
-}
+class GISScaler {
+  // features is an array of feature functions
+  constructor (featureSet, sample) {
+    this.featureSet = featureSet
+    this.sample = sample
+  }
 
-// Returns true if a correction feature is necessary
-GISScaler.prototype.calculateMaxSumOfFeatures = function () {
-  const that = this
-  this.C = 0
-  this.featureSums = {}
-  const listOfSumValues = []
-
-  // Since feature functions are derived from the sample
-  // we can use the sample to calculate the max sum
-  // We look at each sample element only once
-  this.sample.elements.forEach(function (x) {
-    if (!that.featureSums[x.toString()]) {
-      let sum = 0
-      that.featureSet.getFeatures().forEach(function (f) {
-        sum += f.apply(x)
-      })
-      if (sum > that.C) {
-        that.C = sum
+  // Returns true if a correction feature is necessary
+  calculateMaxSumOfFeatures () {
+    const that = this
+    this.C = 0
+    this.featureSums = {}
+    const listOfSumValues = []
+
+    // Since feature functions are derived from the sample
+    // we can use the sample to calculate the max sum
+    // We look at each sample element only once
+    this.sample.elements.forEach(function (x) {
+      if (!that.featureSums[x.toString()]) {
+        let sum = 0
+        that.featureSet.getFeatures().forEach(function (f) {
+          sum += f.apply(x)
+        })
+        if (sum > that.C) {
+          that.C = sum
+        }
+        that.featureSums[x.toString()] = sum
+        listOfSumValues.push(sum)
       }
-      that.featureSums[x.toString()] = sum
-      listOfSumValues.push(sum)
-    }
-  })
-  // console.log("GISScaler:calculateMaxSumOfFeatures:maxSum is " + this.C);
-
-  // Check if a correction feature is necessary
-  listOfSumValues.sort(function (a, b) {
-    return a - b
-  })
-  return (listOfSumValues[0] !== listOfSumValues[listOfSumValues.length - 1])
-}
+    })
+    // console.log("GISScaler:calculateMaxSumOfFeatures:maxSum is " + this.C);
 
-GISScaler.prototype.addCorrectionFeature = function () {
-  if (this.calculateMaxSumOfFeatures()) {
-    // console.log("GISScaler:addCorrectionFeature:C is " + this.C);
-    const that = this
+    // Check if a correction feature is necessary
+    listOfSumValues.sort(function (a, b) {
+      return a - b
+    })
+    return (listOfSumValues[0] !== listOfSumValues[listOfSumValues.length - 1])
+  }
 
-    function f (x) {
-      if (that.featureSums[x.toString()] !== undefined) {
-        return that.C - that.featureSums[x.toString()]
+  addCorrectionFeature () {
+    if (this.calculateMaxSumOfFeatures()) {
+      // console.log("GISScaler:addCorrectionFeature:C is " + this.C);
+      const that = this
+
+      function f (x) {
+        if (that.featureSums[x.toString()] !== undefined) {
+          return that.C - that.featureSums[x.toString()]
+        }
+        return 0
       }
-      return 0
-    }
 
-    const correctionFeature = new Feature(f, 'Correction feature', [])
-    // console.log("GISScaler:addCorrectionFeature:correctionFeature " + JSON.stringify(correctionFeature));
-    this.featureSet.addFeature(correctionFeature)
-  } else {
-    // console.log("Correction feature not needed");
+      const correctionFeature = new Feature(f, 'Correction feature', [])
+      // console.log("GISScaler:addCorrectionFeature:correctionFeature " + JSON.stringify(correctionFeature));
+      this.featureSet.addFeature(correctionFeature)
+    } else {
+      // console.log("Correction feature not needed");
+    }
   }
-}
 
-// This is the Generalised Iterative Scaling algorithm
-// It ends if the improvement in likelihood of the distribution does not
-// improve more than minImprovement or if the maximum number of iterations is
-// reached.
-GISScaler.prototype.run = function (maxIterations, minImprovement) {
-  this.iteration = 0
-  this.improvement = 0
-
-  this.addCorrectionFeature()
-  // Build up the distribution p
-  const alpha = new Array(this.featureSet.size())
-  for (let i = 0; i < alpha.length; i++) {
-    alpha[i] = 1
-  }
-  const p = new Distribution(alpha, this.featureSet, this.sample)
-  // console.log("Distribution created");
-  p.prepare()
-  // console.log("Distribution prepared");
-  let KLDistance = p.KullbackLieblerDistance()
-
-  const newAlpha = new Array(this.featureSet.size())
-  let observedExpectation = 0
-  let expectationApprox = 0
-  do {
-    // console.log("Iteration " + this.iteration + " - Log likelihood of sample: " + likelihood + " - Entropy: " + p.entropy());
-    for (let i = 0; i < this.featureSet.size(); i++) {
-      observedExpectation = this.featureSet.getFeatures()[i].observedExpectation(this.sample)
-      expectationApprox = this.featureSet.getFeatures()[i].expectationApprox(p, this.sample)
-      // console.log("Iteration " + this.iteration + " - Feature " + i);
-      newAlpha[i] = p.alpha[i] * Math.pow(observedExpectation / expectationApprox, 1 / this.C)
-
-      // console.log("GISScaler.run: old alpha[" + i + "]: " + p.alpha[i]);
-      // console.log("GISScaler.run: new alpha[" + i + "]: " + newAlpha[i]);
+  // This is the Generalised Iterative Scaling algorithm
+  // It ends if the improvement in likelihood of the distribution does not
+  // improve more than minImprovement or if the maximum number of iterations is
+  // reached.
+  run (maxIterations, minImprovement) {
+    this.iteration = 0
+    this.improvement = 0
+
+    this.addCorrectionFeature()
+    // Build up the distribution p
+    const alpha = new Array(this.featureSet.size())
+    for (let i = 0; i < alpha.length; i++) {
+      alpha[i] = 1
     }
-
-    // Make the newly calculated parameters current parameters
-    newAlpha.forEach(function (newAlphaj, j) {
-      p.alpha[j] = newAlphaj
-    })
-    // Recalculate a priori and a posteriori probabilities
+    const p = new Distribution(alpha, this.featureSet, this.sample)
+    // console.log("Distribution created");
     p.prepare()
+    // console.log("Distribution prepared");
+    let KLDistance = p.KullbackLieblerDistance()
+
+    const newAlpha = new Array(this.featureSet.size())
+    let observedExpectation = 0
+    let expectationApprox = 0
+    do {
+      // console.log("Iteration " + this.iteration + " - Log likelihood of sample: " + likelihood + " - Entropy: " + p.entropy());
+      for (let i = 0; i < this.featureSet.size(); i++) {
+        observedExpectation = this.featureSet.getFeatures()[i].observedExpectation(this.sample)
+        expectationApprox = this.featureSet.getFeatures()[i].expectationApprox(p, this.sample)
+        // console.log("Iteration " + this.iteration + " - Feature " + i);
+        newAlpha[i] = p.alpha[i] * Math.pow(observedExpectation / expectationApprox, 1 / this.C)
+
+        // console.log("GISScaler.run: old alpha[" + i + "]: " + p.alpha[i]);
+        // console.log("GISScaler.run: new alpha[" + i + "]: " + newAlpha[i]);
+      }
 
-    this.iteration++
-    const newKLDistance = p.KullbackLieblerDistance()
-    this.improvement = KLDistance - newKLDistance
-    // console.log("Iteration " + this.iteration + " - Old likelihood: " + likelihood + " - New likelihood: " + newLikelihood);
-    // console.log("Iteration " + this.iteration + " - Old KL: " + KLDistance + " - New KL: " + newKLDistance);
-
-    KLDistance = newKLDistance
-  } while ((this.iteration < maxIterations) && (this.improvement > minImprovement))
-  // } while (iteration < maxIterations);
-  /*
-  var that = this;
-  this.featureSet.getFeatures().forEach(function(f, j) {
-    console.log("Observed expectation of feature " + j + ": " + f.observedExpectation(that.sample) +
-      " - Expection of feature according to p: " + f.expectationApprox(p, that.sample));
-  });
-  */
-
-  return p
+      // Make the newly calculated parameters current parameters
+      newAlpha.forEach(function (newAlphaj, j) {
+        p.alpha[j] = newAlphaj
+      })
+      // Recalculate a priori and a posteriori probabilities
+      p.prepare()
+
+      this.iteration++
+      const newKLDistance = p.KullbackLieblerDistance()
+      this.improvement = KLDistance - newKLDistance
+      // console.log("Iteration " + this.iteration + " - Old likelihood: " + likelihood + " - New likelihood: " + newLikelihood);
+      // console.log("Iteration " + this.iteration + " - Old KL: " + KLDistance + " - New KL: " + newKLDistance);
+
+      KLDistance = newKLDistance
+    } while ((this.iteration < maxIterations) && (this.improvement > minImprovement))
+    // } while (iteration < maxIterations);
+    /*
+    var that = this;
+    this.featureSet.getFeatures().forEach(function(f, j) {
+      console.log("Observed expectation of feature " + j + ": " + f.observedExpectation(that.sample) +
+        " - Expectation of feature according to p: " + f.expectationApprox(p, that.sample));
+    });
+    */
+
+    return p
+  }
 }
 
 module.exports = GISScaler

package/lib/natural/classifiers/maxent/POS/ME_Corpus.js

@@ -23,40 +23,35 @@ THE SOFTWARE.
 
 'use strict'
 
-const util = require('util')
 const Sample = require('../Sample')
 const Corpus = require('../../../brill_pos_tagger/lib/Corpus')
 
-function MECorpus (data, BROWN, SentenceClass) {
-  MECorpus.super_.call(this, data, BROWN, SentenceClass)
-}
-
-util.inherits(MECorpus, Corpus)
-
-MECorpus.prototype.generateSample = function () {
-  const sample = new Sample([])
-  this.sentences.forEach(function (sentence) {
-    sentence.generateSampleElements(sample)
-  })
-  return sample
-}
-
-// Splits the corpus in a training and testing set.
-// percentageTrain is the size of the training corpus in percent
-// Returns an array with two elements: training corpus, testing corpus
-MECorpus.prototype.splitInTrainAndTest = function (percentageTrain) {
-  const corpusTrain = new MECorpus()
-  const corpusTest = new MECorpus()
-
-  const p = percentageTrain / 100
-  this.sentences.forEach(function (sentence, i) {
-    if (Math.random() < p) {
-      corpusTrain.sentences.push(sentence)
-    } else {
-      corpusTest.sentences.push(sentence)
-    }
-  })
-  return [corpusTrain, corpusTest]
+class MECorpus extends Corpus {
+  generateSample () {
+    const sample = new Sample([])
+    this.sentences.forEach(function (sentence) {
+      sentence.generateSampleElements(sample)
+    })
+    return sample
+  }
+
+  // Splits the corpus in a training and testing set.
+  // percentageTrain is the size of the training corpus in percent
+  // Returns an array with two elements: training corpus, testing corpus
+  splitInTrainAndTest (percentageTrain) {
+    const corpusTrain = new MECorpus()
+    const corpusTest = new MECorpus()
+
+    const p = percentageTrain / 100
+    this.sentences.forEach(function (sentence, i) {
+      if (Math.random() < p) {
+        corpusTrain.sentences.push(sentence)
+      } else {
+        corpusTest.sentences.push(sentence)
+      }
+    })
+    return [corpusTrain, corpusTest]
+  }
 }
 
 module.exports = MECorpus

package/lib/natural/classifiers/maxent/POS/ME_Sentence.js

@@ -23,58 +23,53 @@ THE SOFTWARE.
 
 'use strict'
 
-const util = require('util')
 const Context = require('../Context')
 const Sentence = require('../../../brill_pos_tagger/lib/Sentence')
 const Element = require('./POS_Element')
 
-function MESentence (data) {
-  MESentence.super_.call(this, data)
-}
-
-util.inherits(MESentence, Sentence)
-
-MESentence.prototype.generateSampleElements = function (sample) {
-  const sentence = this.taggedWords
-  sentence.forEach(function (token, index) {
-    const x = new Element(
-      token.tag,
-      new Context({
-        wordWindow: {},
-        tagWindow: {}
-      })
-    )
+class MESentence extends Sentence {
+  generateSampleElements (sample) {
+    const sentence = this.taggedWords
+    sentence.forEach(function (token, index) {
+      const x = new Element(
+        token.tag,
+        new Context({
+          wordWindow: {},
+          tagWindow: {}
+        })
+      )
 
-    // Current word and tag
-    x.b.data.wordWindow['0'] = token.token
-    x.b.data.tagWindow['0'] = sentence[index].tag
+      // Current word and tag
+      x.b.data.wordWindow['0'] = token.token
+      x.b.data.tagWindow['0'] = sentence[index].tag
 
-    // Previous bigram
-    if (index > 1) {
-      x.b.data.tagWindow['-2'] = sentence[index - 2].tag
-      x.b.data.wordWindow['-2'] = sentence[index - 2].token
-    }
+      // Previous bigram
+      if (index > 1) {
+        x.b.data.tagWindow['-2'] = sentence[index - 2].tag
+        x.b.data.wordWindow['-2'] = sentence[index - 2].token
+      }
 
-    // Left bigram
-    if (index > 0) {
-      x.b.data.tagWindow['-1'] = sentence[index - 1].tag
-      x.b.data.wordWindow['-1'] = sentence[index - 1].token
-    }
+      // Left bigram
+      if (index > 0) {
+        x.b.data.tagWindow['-1'] = sentence[index - 1].tag
+        x.b.data.wordWindow['-1'] = sentence[index - 1].token
+      }
 
-    // Right bigram
-    if (index < sentence.length - 1) {
-      x.b.data.tagWindow['1'] = sentence[index + 1].tag
-      x.b.data.wordWindow['1'] = sentence[index + 1].token
-    }
+      // Right bigram
+      if (index < sentence.length - 1) {
+        x.b.data.tagWindow['1'] = sentence[index + 1].tag
+        x.b.data.wordWindow['1'] = sentence[index + 1].token
+      }
 
-    // Next bigram
-    if (index < sentence.length - 2) {
-      x.b.data.tagWindow['2'] = sentence[index + 2].tag
-      x.b.data.wordWindow['2'] = sentence[index + 2].token
-    }
+      // Next bigram
+      if (index < sentence.length - 2) {
+        x.b.data.tagWindow['2'] = sentence[index + 2].tag
+        x.b.data.wordWindow['2'] = sentence[index + 2].token
+      }
 
-    sample.addElement(x)
-  })
+      sample.addElement(x)
+    })
+  }
 }
 
 module.exports = MESentence