def test_blank_config():
file_config = {}
cmdline_args = {}
env_vars = {}
f = write_file_config(file_config)
final_config = RasaNLUConfig(f.name, env_vars, cmdline_args)
assert final_config.as_dict() == defaults
def train_nlu(data, config, model_dir):
training_data = load_data(data)
trainer = Trainer(RasaNLUConfig(config))
trainer.train(training_data)
model_directory = trainer.persist(model_dir, fixed_model_name='geonlu')
interpreter = ____
# Try it out
print(
interpreter.parse(
"I'm looking for a Mexican restaurant in the North of town"))
#SOLUTION
# Import necessary modules
from rasa_nlu.converters import load_data
from rasa_nlu.config import RasaNLUConfig
from rasa_nlu.model import Trainer
# Create args dictionary
args = {"pipeline": "spacy_sklearn"}
# Create a configuration and trainer
config = RasaNLUConfig(cmdline_args=args)
trainer = Trainer(config)
# Load the training data
training_data = load_data("./training_data.json")
# Create an interpreter by training the model
interpreter = trainer.train(training_data)
# Try it out
print(
interpreter.parse(
"I'm looking for a Mexican restaurant in the North of town"))
def __init__(self, model_dir):
from rasa_nlu.model import Metadata, Interpreter
self.interpreter = Interpreter.load(
model_dir, RasaNLUConfig("nlu_model_config.json"))
self._items = {}
def __init__(self,
channels_out,
channel_in='screen',
loglvl='',
config_override=''):
"""Initialises the core functionality and sets up various variables."""
# TODO: add checks to confirm all necessary files are present and readable
# (and writable if applicable)
signal.signal(signal.SIGINT, self.handle_ctrl_c)
self.logger = u.setup_custom_logger('root')
if loglvl.lower().strip() == 'debug':
self.logger.setLevel(logging.DEBUG)
self.logger.info('Logging level set to DEBUG')
elif loglvl.lower().strip() == 'info':
self.logger.setLevel(logging.INFO)
self.logger.info('Logging level set to INFO')
elif loglvl.lower().strip() == 'warn':
self.logger.setLevel(logging.WARN)
self.logger.warn('Logging level set to WARN')
elif loglvl.lower().strip() == '':
self.logger.setLevel(logging.INFO)
else:
self.logger.warn(
'Unrecognised log level input. Defaulting to INFO.')
self.logger.info('Initialisation started')
channel_in_accepted = ['screen']
if channel_in not in channel_in_accepted:
self.logger.error(
'Unrecognised channel input value. Must be one of: ' +
', '.join(channel_in_accepted) + '.')
self.before_quit()
else:
self.CHANNEL_IN = channel_in
self.CHANNELS_OUT = channels_out
self.CHANNELS_OUT[self.CHANNEL_IN] = True
config = configparser.ConfigParser()
if config_override.strip() != '':
config_file = os.path.abspath(config_override.strip())
else:
config_file = os.path.abspath(
os.path.join('config', 'mlb_config.ini'))
try:
dataset = config.read([config_file])
if len(dataset) == 0:
raise IOError
except IOError as e:
self.logger.error('Unable to open config file: ' +
str(config_file))
self.before_quit()
except configparser.Error as e:
self.logger.error('Error with config file: ' + str(config_file))
self.before_quit()
try:
# bot items
self.botname = config.get('bot', 'name')
self.botsubject = config.get('bot', 'subject')
# file items
self.history_file = os.path.abspath(
config.get('files', 'history_file'))
self.pickle_file = os.path.abspath(
config.get('files', 'pickle_file'))
except configparser.Error as e:
self.logger.error('Error reading configuration ' + str(e))
self.before_quit()
self.unpickle_user_dict()
self.SESSION_TIME_LIMIT = 10 # Time in minutes to consider a subsequent interaction to be from a new session
self.user_id = '1234'
self.user = self.get_user(self.user_id)
self.user['msg_output'] = ''
self.user['rude_count'] = 0
self.show_highlight = False
self.show_parse = False
self.user_stats = False
self.show_language = True
#self.langs_handled = {'en':'English'}
#self.langs_handled = {'fr':'French'}
self.langs_handled = {'en': 'English', 'fr': 'French'}
#self.langs_handled = {'en':'English', 'fr':'French', 'de':'German'}
self.lang_interpreters = {}
# This is a more generic equivalent of:
# self.interpreter_de = Interpreter.load('projects/default/current_de', RasaNLUConfig('config/mlb_config_de.json'))
for lang in self.langs_handled:
try:
self.logger.info(
'Configuring interpreter for {language}'.format(
language=self.langs_handled[lang]))
self.lang_interpreters[lang] = Interpreter.load(
'projects/default/current_{lang}'.format(lang=lang),
RasaNLUConfig(
'config/mlb_config_{lang}.json'.format(lang=lang)))
except:
self.logger.error(
'Error with creating interpreter for {language} (lang: {lang})'
.format(language=self.langs_handled[lang], lang=lang))
self.logger.info(
'Maybe you need to train the model? Try equivalent of: python -m rasa_nlu.train -c config/mlb_config_XX.json'
)
self.before_quit()
self.last_input = {}
self.print_user_stats(self.user_stats)
self.logger.info('Initialisation complete')
def run_nlu():
interpreter = Interpreter.load('./models/nlu/default/foodnlu',
RasaNLUConfig('config_spacy.json'))
print(interpreter.parse(u"i would like to have a fish"))
type=int,
help='port on which to run server')
parser.add_argument(
'-t',
'--token',
help=
"auth token. If set, reject requests which don't provide this token as a query parameter"
)
parser.add_argument('-w', '--write', help='file where logs will be saved')
return parser
if __name__ == "__main__":
parser = create_argparser()
cmdline_args = {
key: val
for key, val in vars(parser.parse_args()).items() if val is not None
}
config = RasaNLUConfig(cmdline_args.get("config"), os.environ,
cmdline_args)
print(config.view())
logging.basicConfig(filename=config.log_file, level=config.log_level)
logging.captureWarnings(True)
logging.debug(config.view())
try:
server = RasaNLUServer(config)
server.start()
except KeyboardInterrupt:
server.stop()
def test_failure_on_invalid_lang(self):
config = RasaNLUConfig("config_mitie.json")
with pytest.raises(NotImplementedError):
MITIETrainer(config.mitie_file, 'umpalumpa')
def train(data, config, model_dir):
train_data = load_data(data)
trainer = Trainer(RasaNLUConfig(config))
trainer.train(train_data)
model_directory = trainer.persist(model_dir,
fixed_model_name='request_bot')
def run_nlu():
interpreter = Interpreter.load('./models/nlu/default/weathernlu', RasaNLUConfig('config_spacy.json'))
print(interpreter.parse("I am planning my holiday to Lithuania. I wonder what is the weather out there."))
# Import necessary modules
from rasa_nlu.config import RasaNLUConfig
from rasa_nlu.model import Trainer
pipeline = ["nlp_spacy", "tokenizer_spacy", "ner_crf"]
# Create a config that uses this pipeline
config = RasaNLUConfig(cmdline_args={'pipeline': pipeline})
# Create a trainer that uses this config
trainer = Trainer(config)
# Create an interpreter by training the model
interpreter = trainer.train(training_data)
# Parse some messages
print(interpreter.parse("show me Chinese food in the centre of town"))
print(interpreter.parse("I want an Indian restaurant in the west"))
print(interpreter.parse("are there any good pizza places in the center?"))
def predict_restaurant_nlu(model_dir):
from rasa_nlu.model import Metadata, Interpreter
interpreter = Interpreter.load(model_dir, RasaNLUConfig("../restaurantData/config_nlu.json"))
intent_entities = interpreter.parse('thanks, good bye')
return intent_entities
def train_restaurant_nlu():
train_data = load_data('../restaurantData/franken_data.json')
trainer = Trainer(RasaNLUConfig("../restaurantData/config_mitie.json"))
trainer.train(train_data)
model_dir = trainer.persist('../rst_models/rst_nlu/current')
return model_dir
from rasa_nlu.converters import load_data
from rasa_nlu.config import RasaNLUConfig
from rasa_nlu.model import Trainer
training_data = load_data('data/nlu.md')
trainer = Trainer(RasaNLUConfig("nlu_model_config.json"))
trainer.train(training_data)
model_directory = trainer.persist(
'./projects/default/') # Returns the directory the model is stored in
from rasa_core.domain import TemplateDomain
domain = TemplateDomain.load("restaurant_domain.yml")
from __future__ import unicode_literals
from __future__ import print_function
from __future__ import division
from __future__ import absolute_import
import os
import logging
from rasa_nlu.server import create_app
from rasa_nlu.config import RasaNLUConfig
if __name__ == '__main__':
# Running in WSGI container, configuration will be loaded from the default location
# There is no common support for WSGI runners to pass arguments to the application, hence we need to fallback to
# a default location for the configuration where all the settings should be placed in.
rasa_config = RasaNLUConfig(env_vars=os.environ)
app = create_app(rasa_config)
logging.info("Finished setting up application")
app.run()
def default_config():
return RasaNLUConfig(CONFIG_DEFAULTS_PATH)
def run_train(_config):
config = RasaNLUConfig(cmdline_args=_config)
(trained, path) = do_train(config)
return trained, path
def run_nlu():
interpreter = Interpreter.load('./models/nlu/default/pramata_chatter',
RasaNLUConfig('config_spacy.json'))
print(interpreter.parse(u"Who is my risky customer?"))
def train_nlu(data ='./data/data.json', config = './config_sapcy.json', model_dir = './models/nlu'):
training_data = load_data(data)
trainer = Trainer(RasaNLUConfig(config))
trainer.train(training_data)
model_directory = trainer.persist(model_dir, fixed_model_name = 'stagebot')
return jsonify({"Training" : model_directory }), 200
def run_nlu():
interpreter = Interpreter.load('./models/nlu/default/assistantnlu',
RasaNLUConfig('config_spacy.json'))
print(interpreter.parse(u"XCNS"))
def run_nlu():
query = request.args['q']
print(query)
interpreter = Interpreter.load('./models/nlu/default/stagebot', RasaNLUConfig('config_sapcy.json'))
response = interpreter.parse(query)
return jsonify({"Engine Status" : response}), 200
request.setResponseCode(200)
response = yield self.data_router.start_train_process(
data_string, kwargs)
returnValue(
json_to_string(
{'info': 'new model trained: {}'.format(response)}))
except AlreadyTrainingError as e:
request.setResponseCode(403)
returnValue(json_to_string({"error": "{}".format(e)}))
except InvalidProjectError as e:
request.setResponseCode(404)
returnValue(json_to_string({"error": "{}".format(e)}))
except TrainingException as e:
request.setResponseCode(500)
returnValue(json_to_string({"error": "{}".format(e)}))
if __name__ == '__main__':
# Running as standalone python application
arg_parser = create_argparser()
cmdline_args = {
key: val
for key, val in list(vars(arg_parser.parse_args()).items())
if val is not None
}
rasa_nlu_config = RasaNLUConfig(cmdline_args.get("config"), os.environ,
cmdline_args)
rasa = RasaNLU(rasa_nlu_config)
logger.info('Started http server on port %s' % rasa_nlu_config['port'])
rasa.app.run('0.0.0.0', rasa_nlu_config['port'])
results["F1-score"].append(metrics.f1_score(y, preds, average='weighted'))
results["Precision"].append(
metrics.precision_score(y, preds, average='weighted'))
if __name__ == '__main__': # pragma: no cover
parser = create_argparser()
args = parser.parse_args()
# manual check argument dependency
if args.mode == "crossvalidation":
if args.model is not None:
parser.error("Crossvalidation will train a new model \
- do not specify external model")
nlu_config = RasaNLUConfig(args.config, os.environ, vars(args))
logging.basicConfig(level=nlu_config['log_level'])
if args.mode == "crossvalidation":
data = training_data.load_data(args.data)
data = prepare_data(data, cutoff=5)
results = run_cv_evaluation(data, int(args.folds), nlu_config)
logger.info("CV evaluation (n={})".format(args.folds))
for k, v in results.train.items():
logger.info("train {}: {:.3f} ({:.3f})".format(
k, np.mean(v), np.std(v)))
for k, v in results.test.items():
logger.info("test {}: {:.3f} ({:.3f})".format(
k, np.mean(v), np.std(v)))
elif args.mode == "evaluation":
df.to_csv(r'Tag_results.csv', index=None, header=True) # Don't forget to add '.csv' at the end of the path
def load_model_tag(x):
interpreter = Interpreter.load('models/current/nlu_model')
x = interpreter.parse(x)
print(x)
load_model_tag("")
# ! python -m spacy download en
import spacy
import en_core_web_sm
nlp = en_core_web_sm.load()
doc = nlp(
"Hi, I got a Samung TV series 7 with HDR support, a Vizio soundar connected by HDMI with Atmos support and an apple TV 4K connected to the sound bar by HDMI. My issue is that I can have HDR or Atmos, but no both at the same time. When I launch netflix from the apple TV and HDR is turned on, the movie starts flickering. If I launch the built-in Netflix app I can get HDR but no Atmos. I already talked to my set-box support and the soundbar manufacturer as well, but no one gives me a solution. I tried with different ports, different cables, connecting directly the apple TV to my TV, resetting to factory settings, but nothing works. TV specs:Model UE50NU7020Soft version: 1252 This is my last try, could be something related to the TV? Any setting? Thanks ")
for ent in doc.ents:
print(ent.text, ent.label_)
# doc.similarity(nlp("request"))
from rasa_nlu.config import RasaNLUConfig
from rasa_nlu.model import Trainer
config = RasaNLUConfig(cmdline_args={"pipeline": "spacy_sklearn"})
trainer = Trainer(config)
interpreter = trainer.train(training_data)
def test_default_config():
final_config = RasaNLUConfig()
assert dict(final_config.items()) == defaults
from rasa_nlu.converters import load_data
from rasa_nlu.config import RasaNLUConfig
from rasa_nlu.model import Trainer
training_data = load_data('data/iHCM_intents/navigation')
trainer = Trainer(RasaNLUConfig("configs/config_spacy.json"))
trainer.train(training_data)
model_directory = trainer.persist('projects/') # Returns the directory the model is stored in
from rasa_nlu.converters import load_data
from rasa_nlu.config import RasaNLUConfig
from rasa_nlu.model import Trainer
import os
import shutil
# Path to save the model
SAVE_PATH = './models/trained/'
# Load the training data
training_data = load_data('./data/training.json')
print('training data loaded...')
# Load and train the model
print('training initiated...')
trainer = Trainer(RasaNLUConfig('./config.json'))
trainer.train(training_data)
# Save the model
model_directory = trainer.persist('./models/')
if os.path.exists(SAVE_PATH): # removed old model if exists
shutil.rmtree(SAVE_PATH)
print('{} is removed to save the new model.'.format(SAVE_PATH))
os.rename(model_directory, SAVE_PATH) # rename new model to SAVE_PATH
print('done. model saved @ {}'.format(SAVE_PATH))
def run_nlu():
interpreter = Interpreter.load('./models/nlu/default/geonlu',
RasaNLUConfig('config_spacy.json'))
print(
interpreter.parse(
"My name is Alex,I want to find coordinates of Panjab"))
def train_rasa_nlu():
training_data = load_data('data/intent.md')
trainer = Trainer(RasaNLUConfig("data/config_nlu.json"))
trainer.train(training_data)
model_directory = trainer.persist('models/nlu/', model_name=model_name)
return model_directory
import warnings
warnings.simplefilter("ignore")
from rasa_nlu.config import RasaNLUConfig
from rasa_nlu.model import Trainer
from rasa_nlu.converters import load_data
training_data = load_data("training_data.json")
pipeline = [
"nlp_spacy",
"tokenizer_spacy",
"ner_crf"
]
config = RasaNLUConfig(cmdline_args={"pipeline": pipeline})
trainer = Trainer(config)
model_directory = trainer.persist('./models/')
print(f"Saving metadata at {model_directory}")
interpreter = trainer.train(training_data)
from rasa_nlu.converters import load_data
from rasa_nlu.config import RasaNLUConfig
from rasa_nlu.model import Trainer
training_data = load_data('/root/rasa_nlu/classification/testData2.json')
trainer = Trainer(RasaNLUConfig("/root/rasa_nlu/classification/nlu_config.json"))
trainer.train(training_data)
model_directory = trainer.persist('./projects/default/') # Returns the directory the model is stored in
