feat: nlu

Author: Léo Guillaume

.github/workflows/main.yml

@@ -54,3 +54,5 @@ jobs:
         run: npm publish --access public
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Remove dist folder 🗑️
+        run: rm -rf dist

src/index.ts

@@ -33,6 +33,7 @@ import {
     ConversationContext,
     MemoryConversationContext,
 } from './recognizer'
+import { BrainNLU } from './nlu'
 
 export {
     Language,
@@ -54,5 +55,5 @@ export {
     Recognizer,
     ConversationContext,
     MemoryConversationContext,
-    // BrainNLU,
+    BrainNLU,
 };

src/nlp/nlp-manager.ts

@@ -3,7 +3,7 @@ import { BuiltinMicrosoft } from '@nlpjs/builtin-microsoft';
 import { BuiltinDuckling } from '@nlpjs/builtin-duckling';
 import { containerBootstrap } from '@nlpjs/core-loader';
 import Language from '@nlpjs/language';
-import LangAll from '@nlpjs/lang-all';
+import { LangAll } from '@nlpjs/lang-all';
 import { Nlp } from '@nlpjs/nlp';
 import { Evaluator, Template } from '@nlpjs/evaluator';
 import { fs as requestfs } from '@nlpjs/request';

src/nlp/nlp-util.ts

@@ -27,7 +27,7 @@ import {
   defaultContainer,
   containerBootstrap,
 } from '@nlpjs/core-loader';
-import LangAll from '@nlpjs/lang-all';
+import { LangAll } from '@nlpjs/lang-all';
 
 interface Cultures {
   [key: string]: string;

src/nlu/brain-nlu.ts

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) AXA Group Operations Spain S.A.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import { containerBootstrap } from '@nlpjs/core-loader';
+import { LangAll } from '@nlpjs/lang-all';
+import { NluNeural } from '@nlpjs/nlu';
+
+class BrainNLU {
+  private container: any;
+  private nlu: NluNeural | undefined;
+  private readonly corpus: any[];
+  private readonly settings: any;
+
+  constructor(settings: any = {}) {
+    this.settings = settings;
+    if (!this.settings.container) {
+      this.settings.container = containerBootstrap();
+    }
+    this.container = this.settings.container;
+    this.container.use(LangAll);
+    if (!this.settings.l) {
+      this.nlu = new NluNeural({
+        locale: this.settings.locale || this.settings.language || 'en',
+      });
+    }
+    this.corpus = [];
+  }
+
+  add(utterance: string, intent: string) {
+    this.corpus.push({ utterance, intent });
+  }
+
+  train() {
+    return this.nlu?.train(this.corpus, this.settings);
+  }
+
+  async getClassifications(utterance: string) {
+    const result = await this.nlu?.process(utterance);
+    return result?.classifications.sort((a, b) => b.score - a.score);
+  }
+
+  async getBestClassification(utterance: string) {
+    const result = await this.getClassifications(utterance);
+    return result?.[0];
+  }
+}
+
+export default BrainNLU;

src/nlu/index.ts

@@ -0,0 +1,5 @@
+import BrainNLU from './brain-nlu'
+
+export {
+  BrainNLU,
+};

src/sentiment/sentiment-analyzer.ts

@@ -22,7 +22,7 @@
  */
 
 import { SentimentAnalyzer as SentimentAnalyzerBase } from '@nlpjs/sentiment';
-import LangAll from '@nlpjs/lang-all';
+import { LangAll } from '@nlpjs/lang-all';
 import { Nlu } from '@nlpjs/nlu';
 import { Container } from '@nlpjs/core'
 

src/types/@nlpjs/lang-all.d.ts

@@ -28,5 +28,5 @@ declare module "@nlpjs/lang-all" {
 
 
     const LangAll: LangAll;
-    export = LangAll;
+    export { LangAll };
 }

src/types/@nlpjs/nlu.d.ts

@@ -1,6 +1,119 @@
 declare module '@nlpjs/nlu' {
+    import { EventEmitter } from 'events';
+    import { Container } from '@nlpjs/core';
 
-    export class Nlu {
-        constructor()
+    export interface INluOptions {
+        container?: Container;
+        containerName?: string;
+        autoSave?: boolean;
+        autoLoad?: boolean;
+        persist?: boolean;
+        persistFilename?: string;
+        persistDir?: string;
+        persistInterval?: number;
+        persistStateFilename?: string;
+        persistStateDir?: string;
+        persistStateInterval?: number;
+        log?: boolean;
+        minSamplesPerIntent?: number;
+        trainByDomain?: boolean;
+        languages?: string[];
+        locale?: string;
     }
+
+    export interface INluClassifyPayload {
+        utterance: string;
+        locale?: string;
+        language?: string;
+        domain?: string;
+        timezone?: string;
+        userId?: string;
+        sessionId?: string;
+        additional?: any;
+    }
+
+    export interface INluModel {
+        lang?: string;
+        lastUpdate?: string;
+        minSamplesPerIntent?: number;
+        trainByDomain?: boolean;
+        intentThresholds?: { [name: string]: number };
+        entitiesThresholds?: { [name: string]: number };
+        utterances?: { [locale: string]: { [intent: string]: string[] } };
+        domains?: { [name: string]: { [locale: string]: { [intent: string]: string[] } } };
+        entities?: {
+            [locale: string]: {
+                [name: string]: {
+                    type: string;
+                    values: { [value: string]: any };
+                };
+            };
+        };
+        regex?: { [name: string]: { [locale: string]: string } };
+        stems?: { [locale: string]: { [value: string]: string } };
+    }
+
+    export class Nlu extends EventEmitter {
+        constructor();
+
+        container: Container;
+        model?: INluModel;
+        containerName?: string;
+        locale: string;
+        languages: string[];
+        settings: INluOptions;
+        stopWords: Set<string>;
+        stemmers: {
+            [locale: string]: (str: string) => string;
+        };
+        classifiers: {
+            [locale: string]: {
+                [name: string]: any;
+            };
+        };
+
+        load(): Promise<void>;
+
+        process(payload: INluClassifyPayload): Promise<INluModel>;
+
+        train(): Promise<void>;
+
+        save(): Promise<void>;
+
+        export(): INluModel;
+    }
+
+    export interface NluNeuralSettings {
+        locale?: string;
+        log?: boolean;
+        useNoneFeature?: boolean;
+        noneValue?: number;
+        useNeural?: boolean;
+        stemming?: boolean;
+        useRegExpTokenize?: boolean;
+        useLemma?: boolean;
+        minScore?: number;
+        ner?: any;
+        skipStopWords?: boolean;
+        pipeline?: any;
+    }
+
+    export class NluNeural {
+        constructor(settings?: NluNeuralSettings);
+        settings: NluNeuralSettings;
+        train(corpus: any[], settings?: NluNeuralSettings): Promise<void>;
+        process(utterance: string, context?: any): Promise<{
+            classifications: Array<{
+                intent: string;
+                score: number;
+            }>;
+        }>;
+    }
+
+    export class NluNeuralManager {
+        constructor(settings?: NluNeuralSettings);
+        nlu: NluNeural;
+        container: any;
+    }
+    export function register(container: any, options?: NluNeuralSettings): void;
 }