1194

pending completion

Build # 1194

Build Type

Pull #283

travis-ci-com

Committed by

web-flow

Commit Message

Merge 13721deb0 into 2be1d2787

Pull Request Pull Request #283: Pass thingtalk code to nlp server

Run Details

6755 of 12562 branches covered (53.77%)

Branch coverage included in aggregate %.

17 of 37 new or added lines in 6 files covered. (45.95%)

30 existing lines in 5 files now uncovered.

15459 of 24217 relevant lines covered (63.84%)

1225293.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

46.43

/lib/prediction/localparserclient.js

// -*- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Genie
//
// Copyright 2020 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
"use strict";

const ThingTalk = require('thingtalk');

const Utils = require('../utils/misc-utils');
const I18n = require('../i18n');
const editDistance = require('../utils/edit-distance');

const Predictor = require('./predictor');

const SEMANTIC_PARSING_TASK = 'almond';
const NLU_TASK = 'almond_dialogue_nlu';
const NLG_TASK = 'almond_dialogue_nlg';
const NLG_QUESTION = 'what should the agent say ?';

module.exports = class LocalParserClient {
    constructor(modeldir, locale, platform, exactmatcher = null, tpClient = null, options = {}) {
        this._locale = locale;
        this._langPack = I18n.get(locale);
        this._tokenizer = this._langPack.getTokenizer();
        this._predictor = new Predictor(options.id || 'local', modeldir, options.nprocesses);

        this._exactmatcher = exactmatcher;
        this._tpClient = tpClient;
    }

    async start() {
        await this._predictor.start();
    }
    async stop() {
        await this._predictor.stop();
    }

    async sendUtterance(utterance, contextCode, contextEntities, options = {}) {
        let tokens, entities;
        if (options.tokenized) {
            tokens = utterance.split(' ');
            entities = Utils.makeDummyEntities(utterance);
            if (contextEntities) {
                // safety against weird properties
                for (let key of Object.getOwnPropertyNames(contextEntities)) {
                    if (/^(.+)_([0-9]+)$/.test(key))
                        entities[key] = contextEntities[key];
                }
            }
        } else {
            const tokenized = await this._tokenizer.tokenize(utterance);
            if (contextEntities)
                Utils.renumberEntities(tokenized, contextEntities);
            tokens = tokenized.tokens;
            entities = tokenized.entities;
        }

        let answer = undefined;
        if (options.answer)
            answer = options.answer;

        let result = null;
        let exact = null;

        if (tokens.length === 0) {
            result = [{
                code: ['bookkeeping', 'special', 'special:failed'],
                score: 'Infinity'
            }];
        } else if (tokens.length === 1 && (/^[A-Z]/.test(tokens[0]) || tokens[0] === '1' || tokens[0] === '0')) {
            // if the whole input is just an entity, return that as an answer
            result = [{
                code: ['bookkeeping', 'answer', tokens[0]],
                score: 'Infinity'
            }];
        } else if (options.expect === 'MultipleChoice') {
            const choices = await Promise.all((options.choices || []).map((choice) => this._tokenizer.tokenize(choice)));
            result = choices.map((choice, i) => {
                return {
                    code: ['bookkeeping', 'choice', String(i)],
                    score: -editDistance(tokens, choice.tokens)
                };
            });
            result.sort((a, b) => b.score - a.score);
        } else {
            if (this._exactmatcher)
                exact = this._exactmatcher.get(tokens);
        }

        if (result === null) {
            if (options.expect === 'Location') {
                result = [{
                    code: ['bookkeeping', 'answer', 'location:', '"', ...tokens, '"'],
                    score: 1
                }];
            } else {
                let candidates;
                if (contextCode)
                    candidates = await this._predictor.predict(contextCode.join(' '), tokens.join(' '), answer, NLU_TASK);
                else
                    candidates = await this._predictor.predict(tokens.join(' '), undefined, answer, SEMANTIC_PARSING_TASK);
                result = candidates.map((c) => {
                    return {
                        code: c.answer.split(' '),
                        score: c.score
                    };
               });
            }
        }
        if (exact !== null)
            result = exact.map((code) => ({ code, score: 'Infinity' })).concat(result);

        if (!options.skip_typechecking) {
            const schemas = new ThingTalk.SchemaRetriever(this._tpClient, null, true);

            result = await Promise.all(result.map(async (c) => {
                try {
                    const parsed = ThingTalk.NNSyntax.fromNN(c.code, entities);
                    await parsed.typecheck(schemas);
                    return {
                        code: c.code,
                        score: c.score
                    };
                } catch(e) {
                    return null;
                }
            }));

            result = result.filter((c) => c !== null);

            const programs = [result.map((r) => r.code)];
            ThingTalk.NNSyntax.applyCompatibility(this._locale, programs, entities, options.thingtalk_version);
        }

        return {
            result: 'ok',
            tokens: tokens,
            candidates: result,
            entities: entities
        };
    }

    async generateUtterance(contextCode, contextEntities, targetAct) {
        let candidates = this._predictor.predict(contextCode.join(' ') + ' ' + targetAct.join(' '), NLG_QUESTION, undefined, NLG_TASK);
        candidates = candidates.map((cand) => {
            return {
                answer: this._langPack.postprocessNLG(cand.answer, contextEntities),
                score: cand.score
            };
        });
        return candidates;
    }
};

1	// -- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of Genie
4	//
5	// Copyright 2020 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
20	"use strict";
21
22	const ThingTalk = require('thingtalk');	58✔
23
24	const Utils = require('../utils/misc-utils');	58✔
25	const I18n = require('../i18n');	58✔
26	const editDistance = require('../utils/edit-distance');	58✔
27
28	const Predictor = require('./predictor');	58✔
29
30	const SEMANTIC_PARSING_TASK = 'almond';	58✔
31	const NLU_TASK = 'almond_dialogue_nlu';	58✔
32	const NLG_TASK = 'almond_dialogue_nlg';	58✔
33	const NLG_QUESTION = 'what should the agent say ?';	58✔
34
35	module.exports = class LocalParserClient {	58✔
36	constructor(modeldir, locale, platform, exactmatcher = null, tpClient = null, options = {}) {	3✔
37	this._locale = locale;	1✔
38	this._langPack = I18n.get(locale);	1✔
39	this._tokenizer = this._langPack.getTokenizer();	1✔
40	this._predictor = new Predictor(options.id \|\| 'local', modeldir, options.nprocesses);	1✔
41
42	this._exactmatcher = exactmatcher;	1✔
43	this._tpClient = tpClient;	1✔
44	}
45
46	async start() {
47	await this._predictor.start();	1✔
48	}
49	async stop() {
50	await this._predictor.stop();	1✔
51	}
52
53	async sendUtterance(utterance, contextCode, contextEntities, options = {}) {	×
54	let tokens, entities;
55	if (options.tokenized) {	1!
56	tokens = utterance.split(' ');	1✔
57	entities = Utils.makeDummyEntities(utterance);	1✔
58	if (contextEntities) {	1!
59	// safety against weird properties
60	for (let key of Object.getOwnPropertyNames(contextEntities)) {	1✔
61	if (/^(.+)_([0-9]+)$/.test(key))	×
62	entities[key] = contextEntities[key];	×
63	}
64	}
65	} else {
66	const tokenized = await this._tokenizer.tokenize(utterance);	×
67	if (contextEntities)	×
68	Utils.renumberEntities(tokenized, contextEntities);	×
69	tokens = tokenized.tokens;	×
70	entities = tokenized.entities;	×
71	}
72
73	let answer = undefined;	1✔
74	if (options.answer)	1!
75	answer = options.answer;	1✔
76
77	let result = null;	1✔
78	let exact = null;	1✔
79
80	if (tokens.length === 0) {	1!
81	result = [{	×
82	code: ['bookkeeping', 'special', 'special:failed'],
83	score: 'Infinity'
84	}];
85	} else if (tokens.length === 1 && (/^[A-Z]/.test(tokens[0]) \|\| tokens[0] === '1' \|\| tokens[0] === '0')) {	1!
86	// if the whole input is just an entity, return that as an answer
87	result = [{	×
88	code: ['bookkeeping', 'answer', tokens[0]],
89	score: 'Infinity'
90	}];
91	} else if (options.expect === 'MultipleChoice') {	1!
92	const choices = await Promise.all((options.choices \|\| []).map((choice) => this._tokenizer.tokenize(choice)));	×
93	result = choices.map((choice, i) => {	×
94	return {	×
95	code: ['bookkeeping', 'choice', String(i)],
96	score: -editDistance(tokens, choice.tokens)
97	};
98	});
99	result.sort((a, b) => b.score - a.score);	×
100	} else {
101	if (this._exactmatcher)	1!
102	exact = this._exactmatcher.get(tokens);	×
103	}
104
105	if (result === null) {	1!
106	if (options.expect === 'Location') {	1!
107	result = [{	×
108	code: ['bookkeeping', 'answer', 'location:', '"', ...tokens, '"'],
109	score: 1
110	}];
111	} else {
112	let candidates;
113	if (contextCode)	1!
NEW 114	candidates = await this._predictor.predict(contextCode.join(' '), tokens.join(' '), answer, NLU_TASK);	×
115	else
116	candidates = await this._predictor.predict(tokens.join(' '), undefined, answer, SEMANTIC_PARSING_TASK);	1✔
UNCOV 117	result = candidates.map((c) => {	×
UNCOV 118	return {	×
119	code: c.answer.split(' '),
120	score: c.score
121	};
122	});
123	}
124	}
UNCOV 125	if (exact !== null)	×
126	result = exact.map((code) => ({ code, score: 'Infinity' })).concat(result);	×
127
UNCOV 128	if (!options.skip_typechecking) {	×
129	const schemas = new ThingTalk.SchemaRetriever(this._tpClient, null, true);	×
130
131	result = await Promise.all(result.map(async (c) => {	×
132	try {	×
133	const parsed = ThingTalk.NNSyntax.fromNN(c.code, entities);	×
134	await parsed.typecheck(schemas);	×
135	return {	×
136	code: c.code,
137	score: c.score
138	};
139	} catch(e) {
140	return null;	×
141	}
142	}));
143
144	result = result.filter((c) => c !== null);	×
145
146	const programs = [result.map((r) => r.code)];	×
147	ThingTalk.NNSyntax.applyCompatibility(this._locale, programs, entities, options.thingtalk_version);	×
148	}
149
UNCOV 150	return {	×
151	result: 'ok',
152	tokens: tokens,
153	candidates: result,
154	entities: entities
155	};
156	}
157
158	async generateUtterance(contextCode, contextEntities, targetAct) {
NEW 159	let candidates = this._predictor.predict(contextCode.join(' ') + ' ' + targetAct.join(' '), NLG_QUESTION, undefined, NLG_TASK);	×
160	candidates = candidates.map((cand) => {	×
161	return {	×
162	answer: this._langPack.postprocessNLG(cand.answer, contextEntities),
163	score: cand.score
164	};
165	});
166	return candidates;	×
167	}
168	};

stanford-oval / genie-toolkit / 1194

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous