natural 6.10.2 → 6.10.4

package/.gitconfig

@@ -0,0 +1,3 @@
+[user]
+	email = hwl.ter.doest@gmail.com
+	name = Hugo W.L. ter Doest

package/.github/workflows/node.js.yml

@@ -22,7 +22,7 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
     - run: npm ci

package/.github/workflows/npm-publish.yml

@@ -1,6 +1,6 @@
 # This workflow will run tests using node and then publish a package to NPMjs when a release is created
 # For more information see: https://help.github.com/actions/language-and-framework-guides/publishing-nodejs-packages
-
+---
 name: Node.js Package
 
 on:
@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v4
         with:
           node-version: 12
       - run: npm ci
@@ -23,12 +23,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v4
         with:
           node-version: 14
           registry-url: https://registry.npmjs.org/
       - run: npm ci
-      - run: git config user.name $GITHUB_ACTOR
+      - run: git config user.name "$GITHUB_ACTOR"
       - run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.NPM_SECRET}}

package/lib/natural/brill_pos_tagger/index.d.ts

@@ -23,6 +23,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 */
 
+import { Feature } from '../classifiers'
+
 declare interface RuleTemplatesItem {
   function: (sentence: Sentence, i: number, parameter1?: string, parameter2?: string) => boolean
   window: number[]
@@ -93,8 +95,12 @@ export class Lexicon {
   setDefaultCategories (category: string, categoryCapitalised: string): void
 }
 
-export class Corpus {
+declare class Corpus {
   constructor (data: string | Corpus, typeOfCorpus: number, SentenceClass: typeof Sentence)
+  private readonly wordCount: number
+  private readonly sentences: Sentence[]
+  private readonly tagFrequencies: { [key: string]: string[] | undefined }
+  private readonly posTags: { [key: string]: string[] | undefined }
   parseBrownCorpus (data: string, SentenceClass: typeof Sentence): void
   getTags (): string[]
   splitInTrainAndTest (percentageTrain: number): [Corpus, Corpus]
@@ -103,8 +109,8 @@ export class Corpus {
   tag (lexicon: Lexicon): void
   nrSentences (): number
   nrWords (): number
-  // Incomplete methods
-  // generateFeatures
+  private generateFeatures (): Feature[]
+  // Incomplete method:
   // prettyPrint
 }
 
@@ -122,8 +128,8 @@ export class Sentence {
 
 export class BrillPOSTagger {
   constructor (lexicon: Lexicon, ruleSet: RuleSet)
-  lexicon: Lexicon
-  ruleSet: RuleSet
+  private readonly lexicon: Lexicon
+  private readonly ruleSet: RuleSet
   tag (sentence: string[]): Sentence
   tagWithLexicon (sentence: string[]): Sentence
   applyRules (sentence: Sentence): Sentence
@@ -131,32 +137,32 @@ export class BrillPOSTagger {
 
 export class BrillPOSTester {
   constructor (lexicon: Lexicon, ruleSet: RuleSet)
-  lexicon: Lexicon
-  ruleSet: RuleSet
+  private readonly lexicon: Lexicon
+  private readonly ruleSet: RuleSet
   test (corpus: Corpus, tagger: BrillPOSTagger): [number, number]
 }
 
 export class BrillPOSTrainer {
   constructor (ruleScoreThreshold: number)
-  ruleScoreThreshold: number
-  corpus: Corpus
-  templates: RuleTemplates
-  positiveRules: RuleSet
-  mapRuleToSites: { [key: string]: { [key: number ]: { [key: number ]: boolean | undefined } | undefined } | undefined }
-  mapSiteToRules: { [key: number]: { [key: number ]: { [key: string ]: TransformationRule | undefined } | undefined } | undefined }
-  selectHighRule (): TransformationRule
-  mapRuleToSite (rule: TransformationRule, i: number, j: number): void
-  mapSiteToRule (i: number, j: number, rule: TransformationRule): void
-  associateSiteWithRule (i: number, j: number, rule: TransformationRule): void
-  siteIsAssociatedWithRule (i: number, j: number, rule: TransformationRule): boolean
-  getSites (rule: TransformationRule): Array<[number, number]>
-  getRules (i: number, j: number): TransformationRule[]
-  disconnectSiteFromRule (i: number, j: number, rule: TransformationRule): void
-  scoreRule (rule: TransformationRule, i: number, j: number): void
-  generatePositiveRules (i: number, j: number): RuleSet
-  scanForPositiveRules (): void
-  scanForSites (): void
-  neighbourhood (i: number, j: number): Array<[number, number]>
+  private readonly ruleScoreThreshold: number
+  private readonly corpus: Corpus
+  private readonly templates: RuleTemplates
+  private readonly positiveRules: RuleSet
+  private readonly mapRuleToSites: { [key: string]: { [key: number ]: { [key: number ]: boolean | undefined } | undefined } | undefined }
+  private readonly mapSiteToRules: { [key: number]: { [key: number ]: { [key: string ]: TransformationRule | undefined } | undefined } | undefined }
+  private selectHighRule (): TransformationRule
+  private mapRuleToSite (rule: TransformationRule, i: number, j: number): void
+  private mapSiteToRule (i: number, j: number, rule: TransformationRule): void
+  private associateSiteWithRule (i: number, j: number, rule: TransformationRule): void
+  private siteIsAssociatedWithRule (i: number, j: number, rule: TransformationRule): boolean
+  private getSites (rule: TransformationRule): Array<[number, number]>
+  private getRules (i: number, j: number): TransformationRule[]
+  private disconnectSiteFromRule (i: number, j: number, rule: TransformationRule): void
+  private scoreRule (rule: TransformationRule, i: number, j: number): void
+  private generatePositiveRules (i: number, j: number): RuleSet
+  private scanForPositiveRules (): void
+  private scanForSites (): void
+  private neighbourhood (i: number, j: number): Array<[number, number]>
   train (corpus: Corpus, templates: RuleTemplates, lexicon: Lexicon): RuleSet
   printRulesWithScores (): string
 }

package/lib/natural/brill_pos_tagger/lib/Brill_POS_Tagger.js

@@ -22,42 +22,44 @@ const Sentence = require('./Sentence')
 
 const DEBUG = false
 
-function BrillPOSTagger (lexicon, ruleSet) {
-  this.lexicon = lexicon
-  this.ruleSet = ruleSet
-}
-
-// Tags a sentence, sentence is an array of words
-// Returns an array of tagged words; a tagged words is an array consisting of
-// the word itself followed by its lexical category
-BrillPOSTagger.prototype.tag = function (sentence) {
-  const taggedSentence = this.tagWithLexicon(sentence)
-  DEBUG && console.log(taggedSentence)
-  return this.applyRules(taggedSentence)
-}
+class BrillPOSTagger {
+  constructor (lexicon, ruleSet) {
+    this.lexicon = lexicon
+    this.ruleSet = ruleSet
+  }
 
-BrillPOSTagger.prototype.tagWithLexicon = function (sentence) {
-  const taggedSentence = new Sentence()
+  // Tags a sentence, sentence is an array of words
+  // Returns an array of tagged words; a tagged words is an array consisting of
+  // the word itself followed by its lexical category
+  tag (sentence) {
+    const taggedSentence = this.tagWithLexicon(sentence)
+    DEBUG && console.log(taggedSentence)
+    return this.applyRules(taggedSentence)
+  }
 
-  const that = this
-  sentence.forEach(function (word, index) {
-    const categories = that.lexicon.tagWord(word)
-    taggedSentence.addTaggedWord(word, categories[0])
-  })
-  return (taggedSentence)
-}
+  tagWithLexicon (sentence) {
+    const taggedSentence = new Sentence()
 
-// Applies the transformation rules to an initially tagged sentence.
-// taggedSentence is an array of tagged words.
-// A tagged word is an array consisting of the word itself followed by its lexical category.
-// Returns an array of tagged words as well
-BrillPOSTagger.prototype.applyRules = function (sentence) {
-  for (let i = 0, size = sentence.taggedWords.length; i < size; i++) {
-    this.ruleSet.getRules().forEach(function (rule) {
-      rule.apply(sentence, i)
+    const that = this
+    sentence.forEach(function (word, index) {
+      const categories = that.lexicon.tagWord(word)
+      taggedSentence.addTaggedWord(word, categories[0])
     })
+    return (taggedSentence)
+  }
+
+  // Applies the transformation rules to an initially tagged sentence.
+  // taggedSentence is an array of tagged words.
+  // A tagged word is an array consisting of the word itself followed by its lexical category.
+  // Returns an array of tagged words as well
+  applyRules (sentence) {
+    for (let i = 0, size = sentence.taggedWords.length; i < size; i++) {
+      this.ruleSet.getRules().forEach(function (rule) {
+        rule.apply(sentence, i)
+      })
+    }
+    return sentence
   }
-  return sentence
 }
 
 module.exports = BrillPOSTagger

package/lib/natural/brill_pos_tagger/lib/Brill_POS_Tester.js

@@ -18,43 +18,41 @@
 
 'use strict'
 
-function BrillPOSTester () {
-
-}
-
-BrillPOSTester.prototype.test = function (corpus, tagger) {
-  let totalWords = 0
-  let correctTagsLexicon = 0
-  let correctTagsAfterRules = 0
-
-  // Tag the corpus using the tagger
-  corpus.sentences.forEach(function (sentence) {
-    const s = sentence.taggedWords.map(function (token) {
-      return token.token
-    })
-
-    // Use the lexicon to tag the sentence
-    const taggedSentence = tagger.tagWithLexicon(s)
-    // Count the right tags
-    sentence.taggedWords.forEach(function (token, i) {
-      totalWords++
-      if (token.tag === taggedSentence.taggedWords[i].tag) {
-        correctTagsLexicon++
-      }
-    })
-
-    // Use the rule set to tag the sentence
-    const taggedSentenceAfterRules = tagger.applyRules(taggedSentence)
-    // Count the right tags
-    sentence.taggedWords.forEach(function (token, i) {
-      if (token.tag === taggedSentenceAfterRules.taggedWords[i].tag) {
-        correctTagsAfterRules++
-      }
+class BrillPOSTester {
+  test (corpus, tagger) {
+    let totalWords = 0
+    let correctTagsLexicon = 0
+    let correctTagsAfterRules = 0
+
+    // Tag the corpus using the tagger
+    corpus.sentences.forEach(function (sentence) {
+      const s = sentence.taggedWords.map(function (token) {
+        return token.token
+      })
+
+      // Use the lexicon to tag the sentence
+      const taggedSentence = tagger.tagWithLexicon(s)
+      // Count the right tags
+      sentence.taggedWords.forEach(function (token, i) {
+        totalWords++
+        if (token.tag === taggedSentence.taggedWords[i].tag) {
+          correctTagsLexicon++
+        }
+      })
+
+      // Use the rule set to tag the sentence
+      const taggedSentenceAfterRules = tagger.applyRules(taggedSentence)
+      // Count the right tags
+      sentence.taggedWords.forEach(function (token, i) {
+        if (token.tag === taggedSentenceAfterRules.taggedWords[i].tag) {
+          correctTagsAfterRules++
+        }
+      })
     })
-  })
 
-  // Return percentage right
-  return [100 * correctTagsLexicon / totalWords, 100 * correctTagsAfterRules / totalWords]
+    // Return percentage right
+    return [100 * correctTagsLexicon / totalWords, 100 * correctTagsAfterRules / totalWords]
+  }
 }
 
 module.exports = BrillPOSTester