natural 6.10.2 → 6.10.3

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

@@ -1,7 +1,7 @@
 /*
 Classifier class that provides functionality for training and
 classification
-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
@@ -32,96 +32,98 @@ const Sample = require('./Sample')
 const Scaler = require('./GISScaler')
 const FeatureSet = require('./FeatureSet')
 
-function Classifier (features, sample) {
-  if (features) {
+class Classifier {
+  constructor (features, sample) {
+    if (features) {
+      this.features = features
+    } else {
+      this.features = new FeatureSet()
+    }
     this.features = features
-  } else {
-    this.features = new FeatureSet()
+    if (sample) {
+      this.sample = sample
+    } else {
+      this.sample = new Sample()
+    }
   }
-  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
+  load (filename, ElementClass, callback) {
+    fs.readFile(filename, 'utf8', function (err, data) {
+      if (!err) {
+        const classifierData = JSON.parse(data)
+        const sample = new Sample()
+        classifierData.sample.elements.forEach(function (elementData) {
+          const elt = new ElementClass(elementData.a, new Context(elementData.b.data))
+          sample.addElement(elt)
+        })
+        const featureSet = new FeatureSet()
+        sample.generateFeatures(featureSet)
+        const classifier = new Classifier(featureSet, sample)
+        callback(err, classifier)
+      } else {
+        if (callback) {
+          callback(err)
+        }
+      }
+    })
   }
-}
 
-// 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) {
-      const classifierData = JSON.parse(data)
-      const sample = new Sample()
-      classifierData.sample.elements.forEach(function (elementData) {
-        const elt = new ElementClass(elementData.a, new Context(elementData.b.data))
-        sample.addElement(elt)
-      })
-      const featureSet = new FeatureSet()
-      sample.generateFeatures(featureSet)
-      const classifier = new Classifier(featureSet, sample)
-      callback(err, classifier)
-    } else {
+  save (filename, callback) {
+    const data = JSON.stringify(this, null, 2)
+    const classifier = this
+    fs.writeFile(filename, data, 'utf8', function (err) {
       if (callback) {
-        callback(err)
+        console.log('Saved classifier to ' + filename)
+        callback(err, err ? null : classifier)
       }
-    }
-  })
-}
-
-Classifier.prototype.save = function (filename, callback) {
-  const data = JSON.stringify(this, null, 2)
-  const classifier = this
-  fs.writeFile(filename, data, 'utf8', function (err) {
-    if (callback) {
-      console.log('Saved classifier to ' + filename)
-      callback(err, err ? null : classifier)
-    }
-  })
-}
+    })
+  }
 
-Classifier.prototype.addElement = function (x) {
-  this.sample.addElement(x)
-}
+  addElement (x) {
+    this.sample.addElement(x)
+  }
 
-Classifier.prototype.addDocument = function (context, classification, ElementClass) {
-  Classifier.prototype.addElement(new ElementClass(classification, context))
-}
+  addDocument (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)
-}
+  train (maxIterations, minImprovement, approxExpectation) {
+    this.scaler = new Scaler(this.features, this.sample)
+    this.p = this.scaler.run(maxIterations, minImprovement, approxExpectation)
+  }
 
-Classifier.prototype.getClassifications = function (b) {
-  const scores = []
-  const that = this
-  this.sample.getClasses().forEach(function (a) {
-    const x = new Element(a, b)
-    scores.push({
-      label: a,
-      value: that.p.calculateAPriori(x)
+  getClassifications (b) {
+    const scores = []
+    const that = this
+    this.sample.getClasses().forEach(function (a) {
+      const x = new Element(a, b)
+      scores.push({
+        label: a,
+        value: that.p.calculateAPriori(x)
+      })
     })
-  })
-  return scores
-}
+    return scores
+  }
 
-Classifier.prototype.classify = function (b) {
-  const 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
-  const min = scores[scores.length - 1].value
-  const max = scores[0].value
-  if (min === max) {
-    return ''
-  } else {
-    // Return the highest scoring classes
-    return scores[0].label
+  classify (b) {
+    const 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
+    const min = scores[scores.length - 1].value
+    const max = scores[0].value
+    if (min === max) {
+      return ''
+    } else {
+      // Return the highest scoring classes
+      return scores[0].label
+    }
   }
 }
 

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

@@ -1,6 +1,6 @@
 /*
 Context class
-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
@@ -25,16 +25,18 @@ THE SOFTWARE.
 
 const stringify = require('safe-stable-stringify')
 
-function Context (data) {
-  this.data = data
-}
+class Context {
+  constructor (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)
+  // Create a predictable key string for looking up in a hash
+  toString () {
+    if (!this.key) {
+      this.key = stringify(this.data)
+    }
+    return this.key
   }
-  return this.key
 }
 
 module.exports = Context

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

@@ -1,6 +1,6 @@
 /*
 Distribution class for probability distributions
-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
@@ -25,128 +25,130 @@ THE SOFTWARE.
 
 const 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 () {
+class Distribution {
+  constructor (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
+  toString () {
 
-Distribution.prototype.weight = function (x) {
-  let product = 1
-  const that = this
+  }
 
-  this.alpha.forEach(function (alphaj, j) {
-    product *= Math.pow(alphaj, that.featureSet.getFeatures()[j].apply(x))
-  })
-  return product
-}
+  weight (x) {
+    let product = 1
+    const that = this
 
-Distribution.prototype.calculateAPriori = function (x) {
-  if (!this.aPriorisBeforeNormalisation[x.toString()]) {
-    this.aPriorisBeforeNormalisation[x.toString()] = this.weight(x)
+    this.alpha.forEach(function (alphaj, j) {
+      product *= Math.pow(alphaj, that.featureSet.getFeatures()[j].apply(x))
+    })
+    return product
   }
-  return this.aPriorisBeforeNormalisation[x.toString()]// / this.aPrioriNormalisationConstant;
-}
 
-// Memoize a priori probabilities of sample elements
-Distribution.prototype.prepareWeights = function () {
-  this.aPriorisBeforeNormalisation = {}
-  this.aPrioriNormalisationConstant = 0
-  let sum = 0
-  const that = this
-  this.sample.elements.forEach(function (x) {
-    that.aPriorisBeforeNormalisation[x.toString()] = that.weight(x)
-    sum += that.aPriorisBeforeNormalisation[x.toString()]
-  })
-  this.aPrioriNormalisationConstant = sum
-}
+  calculateAPriori (x) {
+    if (!this.aPriorisBeforeNormalisation[x.toString()]) {
+      this.aPriorisBeforeNormalisation[x.toString()] = this.weight(x)
+    }
+    return this.aPriorisBeforeNormalisation[x.toString()]// / this.aPrioriNormalisationConstant;
+  }
 
-Distribution.prototype.calculateAPosteriori = function (x) {
-  if (!this.aPriorisBeforeNormalisation[x.toString()]) {
-    this.aPriorisBeforeNormalisation[x.toString()] = this.weight(x)
+  // Memoize a priori probabilities of sample elements
+  prepareWeights () {
+    this.aPriorisBeforeNormalisation = {}
+    this.aPrioriNormalisationConstant = 0
+    let sum = 0
+    const that = this
+    this.sample.elements.forEach(function (x) {
+      that.aPriorisBeforeNormalisation[x.toString()] = that.weight(x)
+      sum += that.aPriorisBeforeNormalisation[x.toString()]
+    })
+    this.aPrioriNormalisationConstant = sum
   }
-  if (!this.aPosterioriNormalisationConstants[x.b.toString()]) {
-    this.aPosterioriNormalisationConstants[x.b.toString()] = this.aPosterioriNormalisation(x.b)
+
+  calculateAPosteriori (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()]
   }
-  return this.aPriorisBeforeNormalisation[x] / this.aPosterioriNormalisationConstants[x.b.toString()]
-}
 
-Distribution.prototype.aPosterioriNormalisation = function (b) {
-  let sum = 0
+  aPosterioriNormalisation (b) {
+    let sum = 0
 
-  const that = this
-  this.sample.getClasses().forEach(function (a) {
-    sum += that.weight(new Element(a, b))
-  })
+    const that = this
+    this.sample.getClasses().forEach(function (a) {
+      sum += that.weight(new Element(a, b))
+    })
 
-  return (sum)
-}
+    return (sum)
+  }
 
-// Memoize a posteriori probabilities of sample elements
-Distribution.prototype.prepareAPosterioris = function () {
-  this.aPosterioriNormalisationConstants = {}
-
-  const contextSeen = {}
-  const that = this
-  this.sample.elements.forEach(function (sampleElement) {
-    const context = sampleElement.b
-    if (!contextSeen[context]) {
-      contextSeen[context] = true
-      that.aPosterioriNormalisationConstants[context] =
-        that.aPosterioriNormalisation(context)
-    }
-  })
-}
+  // Memoize a posteriori probabilities of sample elements
+  prepareAPosterioris () {
+    this.aPosterioriNormalisationConstants = {}
+
+    const contextSeen = {}
+    const that = this
+    this.sample.elements.forEach(function (sampleElement) {
+      const 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()
-}
+  // Memoize all probabilities of sample elements
+  prepare () {
+    this.prepareWeights()
+    // console.log("Weights prepared");
+    this.prepareAPosterioris()
+  }
 
-// Relative entropy between observered distribution and derived distribution
-Distribution.prototype.KullbackLieblerDistance = function () {
-  let sum = 0
-  const that = this
-  this.sample.elements.forEach(function (x) {
-    sum += that.sample.observedProbability(x) * Math.log(that.sample.observedProbability(x) / that.calculateAPriori(x))
-  })
-  return sum
-}
+  // Relative entropy between observered distribution and derived distribution
+  KullbackLieblerDistance () {
+    let sum = 0
+    const 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 () {
-  let sum = 0
-  const that = this
-  this.sample.elements.forEach(function (x) {
-    sum += that.sample.observedProbability(x) * Math.log(that.calculateAPriori(x))
-  })
-  return sum
-}
+  logLikelihood () {
+    let sum = 0
+    const that = this
+    this.sample.elements.forEach(function (x) {
+      sum += that.sample.observedProbability(x) * Math.log(that.calculateAPriori(x))
+    })
+    return sum
+  }
 
-Distribution.prototype.entropy = function () {
-  let sum = 0
-  const that = this
-  this.sample.elements.forEach(function (x) {
-    const p = that.calculateAPriori(x)
-    sum += p * Math.log(p)
-  })
-  return sum
-}
+  entropy () {
+    let sum = 0
+    const that = this
+    this.sample.elements.forEach(function (x) {
+      const p = that.calculateAPriori(x)
+      sum += p * Math.log(p)
+    })
+    return sum
+  }
 
-Distribution.prototype.checkSum = function () {
-  let sum = 0
-  const that = this
-  this.sample.elements.forEach(function (x) {
-    sum += that.calculateAPriori(x)
-  })
-  // console.log("Distribution.checkSum is " + sum);
-  return sum
+  checkSum () {
+    let sum = 0
+    const 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

@@ -1,6 +1,6 @@
 /*
 Element class for elements in the event space
-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
@@ -23,17 +23,19 @@ THE SOFTWARE.
 
 'use strict'
 
-// a is class and b is context
-function Element (a, b) {
-  this.a = a
-  this.b = b
-}
+class Element {
+  // a is class and b is context
+  constructor (a, b) {
+    this.a = a
+    this.b = b
+  }
 
-Element.prototype.toString = function () {
-  if (!this.key) {
-    this.key = this.a + this.b.toString()
+  toString () {
+    if (!this.key) {
+      this.key = this.a + this.b.toString()
+    }
+    return this.key
   }
-  return this.key
 }
 
 module.exports = Element

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

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