clwoz-models
Version:
Models for ConversationLearner
261 lines • 10 kB
JavaScript
;
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var ModelUtils_1 = require("./ModelUtils");
var TrainDialog_1 = require("./TrainDialog");
var Action_1 = require("./Action");
var MockData;
(function (MockData) {
function makeEntityValues() {
return [{
"userText": "userText",
"displayText": "displayText",
"builtinType": null,
"resolution": {}
}];
}
MockData.makeEntityValues = makeEntityValues;
function makeFilledEntity(entityId) {
return {
entityId: entityId || ModelUtils_1.ModelUtils.generateGUID(),
values: makeEntityValues()
};
}
MockData.makeFilledEntity = makeFilledEntity;
function makeScoreInput(entityIds) {
var fillledEntities = entityIds ?
entityIds.map(function (eid) { return makeFilledEntity(eid); }) : [makeFilledEntity()];
return {
filledEntities: fillledEntities,
context: {},
maskedActions: []
};
}
MockData.makeScoreInput = makeScoreInput;
function makeTrainScorerStep(labelAction, filledEntityIds) {
return {
input: makeScoreInput(filledEntityIds),
logicResult: undefined,
scoredAction: undefined,
labelAction: labelAction || ModelUtils_1.ModelUtils.generateGUID()
};
}
MockData.makeTrainScorerStep = makeTrainScorerStep;
function makeMetrics() {
return {
wallTime: 10
};
}
MockData.makeMetrics = makeMetrics;
function makeScoreBase() {
return {
actionId: ModelUtils_1.ModelUtils.generateGUID(),
payload: "payload",
isTerminal: true,
actionType: Action_1.ActionTypes.TEXT
};
}
MockData.makeScoreBase = makeScoreBase;
function makeUnscoredAction() {
return __assign(__assign({}, makeScoreBase()), { reason: "reason" });
}
MockData.makeUnscoredAction = makeUnscoredAction;
function makeUnscoredActions() {
var numActions = randomInt(1, 2);
return Array.from({ length: numActions }).map(function () { return makeUnscoredAction(); });
}
MockData.makeUnscoredActions = makeUnscoredActions;
function makeScoredAction() {
return __assign(__assign({}, makeScoreBase()), { score: 0.5 });
}
MockData.makeScoredAction = makeScoredAction;
function makeScoredActions() {
var numActions = randomInt(1, 2);
return Array.from({ length: numActions }).map(function () { return makeScoredAction(); });
}
MockData.makeScoredActions = makeScoredActions;
function makeScoreResponse() {
return {
scoredActions: makeScoredActions(),
unscoredActions: makeUnscoredActions(),
metrics: makeMetrics()
};
}
MockData.makeScoreResponse = makeScoreResponse;
function makeLogScorerStep(predictedAction, filledEntityIds) {
return {
input: makeScoreInput(filledEntityIds),
logicResult: undefined,
predictedAction: predictedAction || ModelUtils_1.ModelUtils.generateGUID(),
predictionDetails: makeScoreResponse(),
stepBeginDatetime: new Date().getTime().toString(),
stepEndDatetime: (new Date().getTime() + 1000).toString(),
metrics: makeMetrics()
};
}
MockData.makeLogScorerStep = makeLogScorerStep;
function makeTrainScorerSteps(scorerSteps) {
return scorerSteps
? Object.keys(scorerSteps).map(function (labelAction) { return makeTrainScorerStep(labelAction, scorerSteps[labelAction]); })
: [];
}
MockData.makeTrainScorerSteps = makeTrainScorerSteps;
function makeLogScorerSteps(scorerSteps) {
return scorerSteps
? Object.keys(scorerSteps).map(function (labelAction) { return makeLogScorerStep(labelAction, scorerSteps[labelAction]); })
: [];
}
MockData.makeLogScorerSteps = makeLogScorerSteps;
function makeLabelEntity(entityId, entityValue) {
return {
"entityId": entityId || ModelUtils_1.ModelUtils.generateGUID(),
"startCharIndex": 0,
"endCharIndex": 5,
"entityText": entityValue || "hello",
"resolution": {},
"builtinType": ""
};
}
MockData.makeLabelEntity = makeLabelEntity;
function makeLabelEntities(entities) {
if (!entities) {
return [makeLabelEntity()];
}
return Object.keys(entities).map(function (key) {
return makeLabelEntity(key, entities[key]);
});
}
MockData.makeLabelEntities = makeLabelEntities;
function makeTextVariation(entities) {
return {
text: entities ? Object.values(entities).join(" ") : "Hello World",
labelEntities: makeLabelEntities(entities)
};
}
MockData.makeTextVariation = makeTextVariation;
function makeTrainExtractorStep(textVariations) {
return {
textVariations: textVariations
? textVariations.map(function (entities) { return makeTextVariation(entities); })
: [makeTextVariation()],
type: TrainDialog_1.ExtractorStepType.USER_INPUT
};
}
MockData.makeTrainExtractorStep = makeTrainExtractorStep;
function makeExtractResponse() {
return {
text: "user text",
predictedEntities: [],
metrics: makeMetrics(),
packageId: ModelUtils_1.ModelUtils.generateGUID(),
definitions: { entities: [], actions: [], trainDialogs: [] }
};
}
MockData.makeExtractResponse = makeExtractResponse;
function makeLogExtractorStep() {
return __assign(__assign({}, makeExtractResponse()), { stepBeginDatetime: new Date().getTime().toString(), stepEndDatetime: (new Date().getTime() + 1000).toString() });
}
MockData.makeLogExtractorStep = makeLogExtractorStep;
function makeTrainRound(roundData) {
return {
extractorStep: makeTrainExtractorStep(roundData.textVariations),
scorerSteps: makeTrainScorerSteps(roundData.scorerSteps)
};
}
MockData.makeTrainRound = makeTrainRound;
function makeLogRound(roundData) {
return {
extractorStep: makeLogExtractorStep(),
scorerSteps: makeLogScorerSteps(roundData.scorerSteps)
};
}
MockData.makeLogRound = makeLogRound;
function makeLogDialog(rounds, id) {
if (rounds === void 0) { rounds = defaultRoundData; }
return {
rounds: rounds.map(function (round) { return makeLogRound(round); }),
createdDateTime: "",
lastModifiedDateTime: "",
logDialogId: id || ModelUtils_1.ModelUtils.generateGUID(),
initialFilledEntities: [],
dialogBeginDatetime: new Date().getTime().toString(),
dialogEndDatetime: (new Date().getTime() + 1000).toString(),
metrics: "metrics",
packageId: "packageId",
targetTrainDialogIds: []
};
}
MockData.makeLogDialog = makeLogDialog;
function makeTrainDialog(rounds, id) {
if (rounds === void 0) { rounds = defaultRoundData; }
return {
rounds: rounds.map(function (round) { return makeTrainRound(round); }),
createdDateTime: "",
lastModifiedDateTime: "",
trainDialogId: id || ModelUtils_1.ModelUtils.generateGUID(),
version: 0,
packageCreationId: 0,
packageDeletionId: 0,
initialFilledEntities: [],
tags: [],
description: "",
sourceLogDialogId: ""
};
}
MockData.makeTrainDialog = makeTrainDialog;
// Return random number between min and max
function randomInt(min, max) {
return Math.floor(Math.random() * (max - min + 1) + min);
}
MockData.randomInt = randomInt;
var defaultRoundData = [
{
textVariations: [{
"entity1_id": "entity1_value",
"entity2_id": "entity2_value"
}],
// Round with one scorer step
scorerSteps: {
"action1": ["entity1_id", "entity2_id"]
}
},
{
textVariations: [{
"entity3_id": "entity3_value"
}],
// Rounds without scorer step
scorerSteps: undefined
},
{
textVariations: [{
"entity3_id": "entity3_value"
}],
// Round with multiple scorer steps
scorerSteps: {
"action2_id": ["entity1_id", "entity3_id"],
"action1_id": ["entity1_id"]
}
},
{
textVariations: [{
"entity1_id": "entity1_value"
}],
// End Round with multiple scorer steps
scorerSteps: {
"action4_id": ["entity1_id", "entity3_id"],
"action1_id": ["entity1_id"]
}
}
];
})(MockData = exports.MockData || (exports.MockData = {}));
//# sourceMappingURL=MockDataUtil.js.map