Train endpoint for domain, and added retraining of domain after updat…

…es in agent, domain and entitites
samtecspg · Dec 11, 2017 · 7442c72 · 7442c72
1 parent b9b289d
commit 7442c72
Show file tree

Hide file tree

Showing 22 changed files with 216 additions and 31 deletions.
diff --git a/api/modules/agent/controllers/import.agent.controller.js b/api/modules/agent/controllers/import.agent.controller.js
@@ -4,6 +4,7 @@ const Boom = require('boom');
 const Flat = require('flat');
 const _ = require('lodash');
 const IntentTools = require('../../intent/tools');
+const DomainTools = require('../../domain/tools');
 
 module.exports = (request, reply) => {
 
@@ -305,8 +306,8 @@ module.exports = (request, reply) => {
                         domainResult.intents = resultIntents;
 
                         Async.waterfall([
-                            Async.apply(IntentTools.retrainModelTool, server, rasa, agentResult.agentName, domainResult.domainName, domainResult.id),
-                            Async.apply(IntentTools.retrainDomainRecognizerTool, server, redis, rasa, agentResult.agentName, agentResult.id)
+                            Async.apply(DomainTools.retrainModelTool, server, rasa, agentResult.agentName, domainResult.domainName, domainResult.id),
+                            Async.apply(DomainTools.retrainDomainRecognizerTool, server, redis, rasa, agentResult.agentName, agentResult.id)
                         ], (errTraining) => {
 
                             if (errTraining){

diff --git a/api/modules/agent/controllers/updateById.agent.controller.js b/api/modules/agent/controllers/updateById.agent.controller.js
@@ -295,8 +295,48 @@ module.exports = (request, reply) => {
             return reply(err, null);
         }
         if (requiresRetrain){
-            //call retrain here
+            Async.waterfall([
+                (callbackGetDomains) => {
+
+                    server.inject(`/agent/${agentId}/domain`, (res) => {
+
+                        if (res.statusCode !== 200){
+                            const error = Boom.create(res.statusCode, 'An error ocurred getting the domains of the agent to train them');
+                            return callbackGetDomains(error, null);
+                        }
+                        return callbackGetDomains(null, res.result);
+                    });
+                },
+                (domains, callbackTrainEachDomain) => {
+
+                    Async.eachLimit(domains, 1, (domain, callbackMapOfDomain) => {
+
+                        server.inject(`/domain/${domain.id}/train`, (res) => {
+
+                            if (res.statusCode !== 200){
+                                const error = Boom.create(res.statusCode, `An error ocurred training the domain ${domain.domain}`);
+                                return callbackMapOfDomain(error);
+                            }
+                            return callbackMapOfDomain(null);
+                        });
+                    }, (err) => {
+
+                        if (err){
+                            return callbackTrainEachDomain(err);
+                        }
+                        return callbackTrainEachDomain(null);
+                    });
+                }
+            ], (errTraining) => {
+
+                if (errTraining){
+                    return reply(errTraining);
+                }
+                return reply(result);
+            });
+        }
+        else {
+            return reply(result);
         }
-        return reply(result);
     });
 };
diff --git a/api/modules/domain/config/domain.route.js b/api/modules/domain/config/domain.route.js
@@ -62,6 +62,16 @@ const DomainRoutes = [
             validate: DomainValidator.findIntentsByDomainId,
             handler: DomainController.findIntentsByDomainId
         }
+    },
+    {
+        method: 'GET',
+        path: '/domain/{id}/train',
+        config: {
+            description: 'Train the specified domain',
+            tags: ['api'],
+            validate: DomainValidator.train,
+            handler: DomainController.train
+        }
     }
 ];
 

diff --git a/api/modules/domain/config/domain.validator.js b/api/modules/domain/config/domain.validator.js
@@ -69,7 +69,7 @@ class DomainValidate {
             params: (() => {
 
                 return {
-                    id: DomainSchema.id.required().description('Id of the agent')
+                    id: DomainSchema.id.required().description('Id of the domain')
                 };
             })(),
             query: (() => {
@@ -81,6 +81,15 @@ class DomainValidate {
             })()
         };
 
+        this.train = {
+            params: (() => {
+
+                return {
+                    id: DomainSchema.id.required().description('Id of the domain')
+                };
+            })()
+        };
+
     }
 }
 

diff --git a/api/modules/domain/controllers/index.js b/api/modules/domain/controllers/index.js
@@ -5,6 +5,7 @@ const UpdateByIdController = require('./updateById.domain.controller');
 const DeleteByIdController = require('./deleteById.domain.controller');
 const FindEntitiesByDomainIdController = require('./findEntitiesByDomainId.domain.controller');
 const FindIntentsByDomainIdController = require('./findIntentsByDomainId.domain.controller');
+const TrainController = require('./train.domain.controller');
 
 const DomainController = {
 
@@ -18,7 +19,9 @@ const DomainController = {
 
     findEntitiesByDomainId: FindEntitiesByDomainIdController,
 
-    findIntentsByDomainId: FindIntentsByDomainIdController
+    findIntentsByDomainId: FindIntentsByDomainIdController,
+
+    train: TrainController
 };
 
 module.exports = DomainController;
diff --git a/api/modules/domain/controllers/train.domain.controller.js b/api/modules/domain/controllers/train.domain.controller.js
@@ -0,0 +1,94 @@
+'use strict';
+const Async = require('async');
+const Boom = require('boom');
+const DomainTools = require('../tools');
+
+module.exports = (request, reply) => {
+
+    let agentId = null;
+    let domain = null;
+    const domainId = request.params.id;
+    const server = request.server;
+    const redis = server.app.redis;
+    const rasa = server.app.rasa;
+
+    Async.waterfall([
+        (callback) => {
+
+            server.inject(`/domain/${domainId}`, (res) => {
+
+                if (res.statusCode !== 200){
+                    const error = Boom.create(res.statusCode, 'An error ocurred getting the domain');
+                    return callback(error, null);
+                }
+                domain = res.result;
+                return callback(null);
+            });
+        },
+        (callback) => {
+
+            redis.zscore('agents', domain.agent, (err, id) => {
+
+                if (err){
+                    const error = Boom.badImplementation('An error ocurred checking if the agent exists.');
+                    return callback(error);
+                }
+                if (id){
+                    agentId = id;
+                    return callback(null);
+                }
+                const error = Boom.badRequest(`The agent ${domain.agent} of the specified domain doesn't exist`);
+                return callback(error);
+            });
+        },
+        (callback) => {
+
+            redis.zscore('agents', domain.agent, (err, id) => {
+
+                if (err){
+                    const error = Boom.badImplementation('An error ocurred checking if the agent exists.');
+                    return callback(error);
+                }
+                if (id){
+                    agentId = id;
+                    return callback(null);
+                }
+                const error = Boom.badRequest(`The agent ${domain.agent} of the specified domain doesn't exist`);
+                return callback(error);
+            });
+        },
+        (callback) => {
+
+            DomainTools.retrainModelTool(server, rasa, domain.agent, domain.domainName, domainId, (err) => {
+
+                if (err){
+                    return callback(err);
+                }
+                return callback(null);
+            });
+        },
+        (callback) => {
+
+            DomainTools.retrainDomainRecognizerTool(server, redis, rasa, domain.agent, agentId, (err) => {
+
+                if (err){
+                    return callback(err);
+                }
+                return callback(null);
+            });
+        }
+    ], (err) => {
+
+        if (err){
+            return reply(err);
+        }
+        server.inject(`/domain/${domainId}`, (res) => {
+
+            if (res.statusCode !== 200){
+                const error = Boom.create(res.statusCode, 'An error ocurred getting the domain after training');
+                return callback(error, null);
+            }
+            return reply(res.result);
+        });
+    });
+};
diff --git a/api/modules/domain/controllers/updateById.domain.controller.js b/api/modules/domain/controllers/updateById.domain.controller.js
@@ -200,8 +200,17 @@ module.exports = (request, reply) => {
             return reply(err, null);
         }
         if (requiresRetrain){
-            //call retrain here
+            server.inject(`/domain/${domainId}/train`, (res) => {
+
+                if (res.statusCode !== 200){
+                    const error = Boom.create(res.statusCode, `An error ocurred retraining the domain ${result.domain} after the update`);
+                    reply(error);
+                }
+                reply(res.result);
+            });
+        }
+        else {
+            return reply(result);
         }
-        return reply(result);
     });
 };
diff --git a/...ainRecognitionTrainingData.intent.tool.js → ...ainRecognitionTrainingData.domain.tool.js b/...ainRecognitionTrainingData.intent.tool.js → ...ainRecognitionTrainingData.domain.tool.js
@@ -1,8 +1,8 @@
 'use strict';
 
 const _ = require('lodash');
-const GetAgentData = require('./getAgentData.intent.tool');
-const GetEntitiesCombinations = require('./getEntitiesCombinations.intent.tool');
+const GetAgentData = require('./getAgentData.domain.tool');
+const GetEntitiesCombinations = require('./getEntitiesCombinations.domain.tool');
 
 const buildDomainRecognitionTrainingData = (server, agentId, cb) => {
 

diff --git a/...nt/tools/buildTrainingData.intent.tool.js → ...in/tools/buildTrainingData.domain.tool.js b/...nt/tools/buildTrainingData.intent.tool.js → ...in/tools/buildTrainingData.domain.tool.js
@@ -1,8 +1,8 @@
 'use strict';
 
 const _ = require('lodash');
-const GetDomainData = require('./getDomainData.intent.tool');
-const GetEntitiesCombinations = require('./getEntitiesCombinations.intent.tool');
+const GetDomainData = require('./getDomainData.domain.tool');
+const GetEntitiesCombinations = require('./getEntitiesCombinations.domain.tool');
 
 const buildTrainingData = (server, domainId, callback) => {
 

diff --git a/...ent/tools/cartesianProduct.intent.tool.js → ...ain/tools/cartesianProduct.domain.tool.js b/...ent/tools/cartesianProduct.intent.tool.js → ...ain/tools/cartesianProduct.domain.tool.js
diff --git a/.../intent/tools/getAgentData.intent.tool.js → .../domain/tools/getAgentData.domain.tool.js b/.../intent/tools/getAgentData.intent.tool.js → .../domain/tools/getAgentData.domain.tool.js
diff --git a/...intent/tools/getDomainData.intent.tool.js → ...domain/tools/getDomainData.domain.tool.js b/...intent/tools/getDomainData.intent.tool.js → ...domain/tools/getDomainData.domain.tool.js
diff --git a/...ls/getEntitiesCombinations.intent.tool.js → ...ls/getEntitiesCombinations.domain.tool.js b/...ls/getEntitiesCombinations.intent.tool.js → ...ls/getEntitiesCombinations.domain.tool.js
@@ -2,7 +2,7 @@
 
 const _ = require('lodash');
 
-const CartesianProduct = require('./cartesianProduct.intent.tool');
+const CartesianProduct = require('./cartesianProduct.domain.tool');
 
 const getCombinationOfEntities = (entities, intents) => {
 

diff --git a/api/modules/domain/tools/index.js b/api/modules/domain/tools/index.js
@@ -0,0 +1,12 @@
+'use strict';
+const RetrainModelTool = require('./retrainModel.domain.tool');
+const RetrainDomainRecognizerTool = require('./retrainDomainRecognizer.domain.tool');
+
+const DomainTools = {
+
+    retrainModelTool: RetrainModelTool,
+
+    retrainDomainRecognizerTool: RetrainDomainRecognizerTool
+};
+
+module.exports = DomainTools;
diff --git a/...ls/retrainDomainRecognizer.intent.tool.js → ...ls/retrainDomainRecognizer.domain.tool.js b/...ls/retrainDomainRecognizer.intent.tool.js → ...ls/retrainDomainRecognizer.domain.tool.js
@@ -3,7 +3,7 @@
 const Wreck = require('wreck');
 const Boom = require('boom');
 
-const BuildDomainRecognitionTrainingData = require('./buildDomainRecognitionTrainingData.intent.tool');
+const BuildDomainRecognitionTrainingData = require('./buildDomainRecognitionTrainingData.domain.tool');
 
 const retrainDomainRecognizer = (server, redis, rasa, agentName, agentId, cb) => {
 

diff --git a/.../intent/tools/retrainModel.intent.tool.js → .../domain/tools/retrainModel.domain.tool.js b/.../intent/tools/retrainModel.intent.tool.js → .../domain/tools/retrainModel.domain.tool.js
@@ -3,7 +3,7 @@
 const Wreck = require('wreck');
 const Boom = require('boom');
 const Guid = require('guid');
-const BuildTrainingData = require('./buildTrainingData.intent.tool');
+const BuildTrainingData = require('./buildTrainingData.domain.tool');
 
 const retrainModel = (server, rasa, agentName, domainName, domainId, callback) => {
 

diff --git a/api/modules/entity/controllers/updateById.entity.controller.js b/api/modules/entity/controllers/updateById.entity.controller.js
@@ -285,8 +285,19 @@ module.exports = (request, reply) => {
                                     }
                                     return callbackUpdateIntentsAndScenarios(null);
                                 });
+                            },
+                            (callbackRetrainDomains) => {
+
+                                server.inject(`/domain/${domain}/train`, (res) => {
+
+                                    if (res.statusCode !== 200){
+                                        const error = Boom.create(res.statusCode, `An error ocurred training the domain ${domain}`);
+                                        return callbackMapOfDomains(error);
+                                    }
+                                    return callbackMapOfDomains(null);
+                                });
                             }
-                        ], (err, result) => {
+                        ], (err) => {
 
                             if (err){
                                 return callbackMapOfDomains(err);
@@ -306,7 +317,6 @@ module.exports = (request, reply) => {
                 if (err){
                     return reply(err);
                 }
-                //call retrain here
                 return reply(updatedEntity);
             });
         }

diff --git a/api/modules/intent/controllers/add.intent.controller.js b/api/modules/intent/controllers/add.intent.controller.js
@@ -3,6 +3,7 @@ const Async = require('async');
 const Boom = require('boom');
 const Flat = require('flat');
 const IntentTools = require('../tools');
+const DomainTools = require('../../domain/tools');
 
 module.exports = (request, reply) => {
 
@@ -132,8 +133,8 @@ module.exports = (request, reply) => {
             (cb) => {
 
                 Async.waterfall([
-                    Async.apply(IntentTools.retrainModelTool, server, rasa, resultIntent.agent, resultIntent.domain, domainId),
-                    Async.apply(IntentTools.retrainDomainRecognizerTool, server, redis, rasa, resultIntent.agent, agentId)
+                    Async.apply(DomainTools.retrainModelTool, server, rasa, resultIntent.agent, resultIntent.domain, domainId),
+                    Async.apply(DomainTools.retrainDomainRecognizerTool, server, redis, rasa, resultIntent.agent, agentId)
                 ], (err) => {
 
                     if (err){

diff --git a/api/modules/intent/controllers/deleteById.intent.controller.js b/api/modules/intent/controllers/deleteById.intent.controller.js
@@ -2,6 +2,7 @@
 const Async = require('async');
 const Boom = require('boom');
 const IntentTools = require('../tools');
+const DomainTools = require('../../domain/tools');
 
 module.exports = (request, reply) => {
 
@@ -119,8 +120,8 @@ module.exports = (request, reply) => {
             (callback) => {
 
                 Async.waterfall([
-                    Async.apply(IntentTools.retrainModelTool, server, rasa, intent.agent, intent.domain, domainId),
-                    Async.apply(IntentTools.retrainDomainRecognizerTool, server, redis, rasa, intent.agent, agentId)
+                    Async.apply(DomainTools.retrainModelTool, server, rasa, intent.agent, intent.domain, domainId),
+                    Async.apply(DomainTools.retrainDomainRecognizerTool, server, redis, rasa, intent.agent, agentId)
                 ], (err) => {
 
                     if (err){

diff --git a/api/modules/intent/controllers/updateById.intent.controller.js b/api/modules/intent/controllers/updateById.intent.controller.js
@@ -3,6 +3,7 @@ const Async = require('async');
 const Boom = require('boom');
 const Flat = require('flat');
 const IntentTools = require('../tools');
+const DomainTools = require('../../domain/tools');
 const _ = require('lodash');
 
 const updateDataFunction = (redis, server, rasa, intentId, currentIntent, updateData, agentId, domainId, cb) => {
@@ -44,8 +45,8 @@ const updateDataFunction = (redis, server, rasa, intentId, currentIntent, update
                     (callback) => {
 
                         Async.waterfall([
-                            Async.apply(IntentTools.retrainModelTool, server, rasa, resultIntent.agent, resultIntent.domain, domainId),
-                            Async.apply(IntentTools.retrainDomainRecognizerTool, server, redis, rasa, resultIntent.agent, agentId)
+                            Async.apply(DomainTools.retrainModelTool, server, rasa, resultIntent.agent, resultIntent.domain, domainId),
+                            Async.apply(DomainTools.retrainDomainRecognizerTool, server, redis, rasa, resultIntent.agent, agentId)
                         ], (err) => {
 
                             if (err){