def test_evolving(self, model, conf_file, model_dir, mode):
if 'E' in mode:
c = test_configs_path / conf_file
model_path = download_path / model_dir
if 'IP' not in mode and 'TI' not in mode:
config_path = str(test_configs_path.joinpath(conf_file))
deep_download(['-test', '-c', config_path])
shutil.rmtree(str(model_path), ignore_errors=True)
logfile = io.BytesIO(b'')
_, exitstatus = pexpect.run(sys.executable +
" -m deeppavlov.evolve " + str(c) +
" --iterations 1 --p_size 1",
timeout=None,
withexitstatus=True,
logfile=logfile)
if exitstatus != 0:
logfile.seek(0)
raise RuntimeError(
'Training process of {} returned non-zero exit code: \n{}'.
format(
model_dir, ''.join(
(line.decode() for line in logfile.readlines()))))
shutil.rmtree(str(download_path), ignore_errors=True)
else:
pytest.skip("Unsupported mode: {}".format(mode))
def test_param_search(self, model, conf_file, model_dir, mode):
if 'PS' in mode:
c = test_configs_path / conf_file
model_path = download_path / model_dir
if 'IP' not in mode and 'TI' not in mode:
config_path = str(test_configs_path.joinpath(conf_file))
deep_download(['-c', config_path])
shutil.rmtree(str(model_path), ignore_errors=True)
logfile = io.BytesIO(b'')
p = pexpect.popen_spawn.PopenSpawn(
sys.executable + f" -m deeppavlov.paramsearch {c} --folds 2",
timeout=None,
logfile=logfile)
p.readlines()
if p.wait() != 0:
raise RuntimeError(
'Training process of {} returned non-zero exit code: \n{}'.
format(model_dir,
logfile.getvalue().decode()))
shutil.rmtree(str(download_path), ignore_errors=True)
else:
pytest.skip("Unsupported mode: {}".format(mode))
def test_param_search():
model_dir = 'faq'
conf_file = 'paramsearch/tfidf_logreg_autofaq_psearch.json'
download_config(conf_file)
c = test_configs_path / conf_file
model_path = download_path / model_dir
install_config(c)
deep_download(c)
shutil.rmtree(str(model_path), ignore_errors=True)
logfile = io.BytesIO(b'')
p = pexpect.popen_spawn.PopenSpawn(
sys.executable + f" -m deeppavlov.paramsearch {c} --folds 2",
timeout=None,
logfile=logfile)
p.readlines()
if p.wait() != 0:
raise RuntimeError(
'Training process of {} returned non-zero exit code: \n{}'.format(
model_dir,
logfile.getvalue().decode()))
shutil.rmtree(str(download_path), ignore_errors=True)
def test_consecutive_training_and_interacting(self, model, conf_file,
model_dir, mode):
if 'TI' in mode:
c = test_configs_path / conf_file
model_path = download_path / model_dir
if 'IP' not in mode:
config_path = str(test_configs_path.joinpath(conf_file))
install_config(config_path)
deep_download(config_path)
shutil.rmtree(str(model_path), ignore_errors=True)
logfile = io.BytesIO(b'')
p = pexpect.popen_spawn.PopenSpawn(
sys.executable + " -m deeppavlov train " + str(c),
timeout=None,
logfile=logfile)
p.readlines()
if p.wait() != 0:
raise RuntimeError(
'Training process of {} returned non-zero exit code: \n{}'.
format(model_dir,
logfile.getvalue().decode()))
self.interact(c, model_dir)
shutil.rmtree(str(download_path), ignore_errors=True)
else:
pytest.skip("Unsupported mode: {}".format(mode))
def main():
args = parser.parse_args()
pipeline_config_path = find_config(args.config_path)
if args.download or args.mode == 'download':
deep_download(['-c', pipeline_config_path])
token = args.token or os.getenv('TELEGRAM_TOKEN')
if args.mode == 'train':
train_evaluate_model_from_config(pipeline_config_path)
elif args.mode == 'evaluate':
train_evaluate_model_from_config(pipeline_config_path,
to_train=False,
to_validate=False)
elif args.mode == 'interact':
interact_model(pipeline_config_path)
elif args.mode == 'interactbot':
if not token:
log.error(
'Token required: initiate -t param or TELEGRAM_BOT env var with Telegram bot token'
)
else:
interact_model_by_telegram(pipeline_config_path, token)
elif args.mode == 'riseapi':
start_model_server(pipeline_config_path)
elif args.mode == 'predict':
predict_on_stream(pipeline_config_path, args.batch_size,
args.file_path)
def main():
args = parser.parse_args()
pipeline_config_path = find_config(args.config_path)
https = args.https
ssl_key = args.key
ssl_cert = args.cert
if args.download or args.mode == 'download':
deep_download(pipeline_config_path)
multi_instance = args.multi_instance
stateful = args.stateful
start_epoch_num = args.start_epoch_num
if args.mode == 'train':
train_evaluate_model_from_config(pipeline_config_path, recursive=args.recursive,
start_epoch_num=start_epoch_num)
elif args.mode == 'evaluate':
train_evaluate_model_from_config(pipeline_config_path, to_train=False, to_validate=False,
start_epoch_num=start_epoch_num)
elif args.mode == 'interact':
interact_model(pipeline_config_path)
elif args.mode == 'interactbot':
token = args.token
interact_model_by_telegram(pipeline_config_path, token)
elif args.mode == 'interactmsbot':
ms_id = args.ms_id
ms_secret = args.ms_secret
run_ms_bf_default_agent(model_config=pipeline_config_path,
app_id=ms_id,
app_secret=ms_secret,
multi_instance=multi_instance,
stateful=stateful,
port=args.port)
elif args.mode == 'alexa':
run_alexa_default_agent(model_config=pipeline_config_path,
multi_instance=multi_instance,
stateful=stateful,
port=args.port,
https=https,
ssl_key=ssl_key,
ssl_cert=ssl_cert)
elif args.mode == 'riseapi':
alice = args.api_mode == 'alice'
if alice:
start_alice_server(pipeline_config_path, https, ssl_key, ssl_cert, port=args.port)
else:
start_model_server(pipeline_config_path, https, ssl_key, ssl_cert, port=args.port)
elif args.mode == 'predict':
predict_on_stream(pipeline_config_path, args.batch_size, args.file_path)
elif args.mode == 'install':
install_from_config(pipeline_config_path)
elif args.mode == 'crossval':
if args.folds < 2:
log.error('Minimum number of Folds is 2')
else:
n_folds = args.folds
calc_cv_score(pipeline_config_path, n_folds=n_folds, is_loo=False)
def test_consecutive_training_and_interacting(self, model, conf_file,
model_dir, mode):
if 'TI' in mode:
c = test_configs_path / conf_file
model_path = download_path / model_dir
if 'IP' not in mode:
config_path = str(test_configs_path.joinpath(conf_file))
deep_download(['-test', '-c', config_path])
shutil.rmtree(str(model_path), ignore_errors=True)
logfile = io.BytesIO(b'')
_, exitstatus = pexpect.run("python3 -m deeppavlov.deep train " +
str(c),
timeout=None,
withexitstatus=True,
logfile=logfile)
if exitstatus != 0:
logfile.seek(0)
raise RuntimeError(
'Training process of {} returned non-zero exit code: \n{}'.
format(
model_dir, ''.join(
(line.decode() for line in logfile.readlines()))))
self.interact(c, model_dir)
shutil.rmtree(str(download_path), ignore_errors=True)
else:
pytest.skip("Unsupported mode: {}".format(mode))
def main():
args = parser.parse_args()
pipeline_config_path = args.config_path
if not Path(pipeline_config_path).is_file():
configs = [c for c in Path(__file__).parent.glob(f'configs/**/{pipeline_config_path}.json')
if str(c.with_suffix('')).endswith(pipeline_config_path)] # a simple way to not allow * and ?
if configs:
log.info(f"Interpriting '{pipeline_config_path}' as '{configs[0]}'")
pipeline_config_path = str(configs[0])
token = args.token or os.getenv('TELEGRAM_TOKEN')
if args.download or args.mode == 'download':
deep_download(['-c', pipeline_config_path])
if args.mode == 'train':
train_model_from_config(pipeline_config_path)
elif args.mode == 'interact':
interact_model(pipeline_config_path)
elif args.mode == 'interactbot':
if not token:
log.error('Token required: initiate -t param or TELEGRAM_BOT env var with Telegram bot token')
else:
interact_model_by_telegram(pipeline_config_path, token)
elif args.mode == 'riseapi':
start_model_server(pipeline_config_path)
elif args.mode == 'predict':
predict_on_stream(pipeline_config_path, args.batch_size, args.file_path)
def test_evolving():
model_dir = 'evolution'
conf_file = 'evolution/evolve_intents_snips.json'
download_config(conf_file)
c = test_configs_path / conf_file
model_path = download_path / model_dir
install_config(c)
deep_download(c)
shutil.rmtree(str(model_path), ignore_errors=True)
logfile = io.BytesIO(b'')
p = pexpect.popen_spawn.PopenSpawn(
sys.executable +
f" -m deeppavlov.evolve {c} --iterations 1 --p_size 1",
timeout=None,
logfile=logfile)
p.readlines()
if p.wait() != 0:
raise RuntimeError(
'Training process of {} returned non-zero exit code: \n{}'.format(
model_dir,
logfile.getvalue().decode()))
shutil.rmtree(str(download_path), ignore_errors=True)
def test_interacting_pretrained_model(self, model, conf_file, model_dir, mode):
if 'IP' in mode:
config_file_path = str(test_configs_path.joinpath(conf_file))
deep_download(['-test', '-c', config_file_path])
self.interact(test_configs_path / conf_file, model_dir, PARAMS[model][(conf_file, model_dir, mode)])
else:
pytest.skip("Unsupported mode: {}".format(mode))
def main():
args = parser.parse_args()
pipeline_config_path = find_config(args.config_path)
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_id
log.info("use gpu id:" + args.gpu_id)
if args.download or args.mode == 'download':
deep_download(pipeline_config_path)
multi_instance = args.multi_instance
stateful = args.stateful
start_epoch_num = args.start_epoch_num
if args.mode == 'train':
train_evaluate_model_from_config(pipeline_config_path,
recursive=args.recursive,
start_epoch_num=start_epoch_num)
elif args.mode == 'evaluate':
train_evaluate_model_from_config(pipeline_config_path,
to_train=False,
to_validate=False,
start_epoch_num=start_epoch_num)
elif args.mode == 'interact':
interact_model(pipeline_config_path)
elif args.mode == 'interactbot':
token = args.token
interact_model_by_telegram(pipeline_config_path, token)
elif args.mode == 'interactmsbot':
ms_id = args.ms_id
ms_secret = args.ms_secret
run_ms_bf_default_agent(model_config=pipeline_config_path,
app_id=ms_id,
app_secret=ms_secret,
multi_instance=multi_instance,
stateful=stateful)
elif args.mode == 'riseapi':
alice = args.api_mode == 'alice'
https = args.https
ssl_key = args.key
ssl_cert = args.cert
if alice:
start_alice_server(pipeline_config_path, https, ssl_key, ssl_cert)
else:
start_model_server(pipeline_config_path, https, ssl_key, ssl_cert)
elif args.mode == 'predict':
predict_on_stream(pipeline_config_path, args.batch_size,
args.file_path)
elif args.mode == 'install':
install_from_config(pipeline_config_path)
elif args.mode == 'crossval':
if args.folds < 2:
log.error('Minimum number of Folds is 2')
else:
n_folds = args.folds
calc_cv_score(pipeline_config_path, n_folds=n_folds, is_loo=False)
def test_interacting_pretrained_model(self, model, conf_file, model_dir, mode):
if 'IP' in mode:
config_file_path = str(test_configs_path.joinpath(conf_file))
install_config(config_file_path)
deep_download(config_file_path)
self.interact(test_configs_path / conf_file, model_dir, PARAMS[model][(conf_file, model_dir, mode)])
else:
pytest.skip("Unsupported mode: {}".format(mode))
def test_inferring_pretrained_model(self, model, conf_file, model_dir,
mode):
if 'IP' in mode:
config_file_path = str(test_configs_path.joinpath(conf_file))
install_config(config_file_path)
deep_download(config_file_path)
self.infer(test_configs_path / conf_file,
PARAMS[model][(conf_file, model_dir, mode)])
else:
pytest.skip("Unsupported mode: {}".format(mode))
def build_model(config: Union[str, Path, dict],
mode: str = 'infer',
load_trained: bool = False,
download: bool = False,
serialized: Optional[bytes] = None) -> Chainer:
"""Build and return the model described in corresponding configuration file."""
config = parse_config(config)
if serialized:
serialized: list = pickle.loads(serialized)
if download:
deep_download(config)
import_packages(config.get('metadata', {}).get('imports', []))
model_config = config['chainer']
model = Chainer(model_config['in'], model_config['out'],
model_config.get('in_y'))
for component_config in model_config['pipe']:
if load_trained and ('fit_on' in component_config
or 'in_y' in component_config):
try:
component_config['load_path'] = component_config['save_path']
except KeyError:
log.warning(
'No "save_path" parameter for the {} component, so "load_path" will not be renewed'
.format(
component_config.get(
'class_name',
component_config.get('ref', 'UNKNOWN'))))
if serialized and 'in' in component_config:
component_serialized = serialized.pop(0)
else:
component_serialized = None
component = from_params(component_config,
mode=mode,
serialized=component_serialized)
if 'id' in component_config:
model._components_dict[component_config['id']] = component
if 'in' in component_config:
c_in = component_config['in']
c_out = component_config['out']
in_y = component_config.get('in_y', None)
main = component_config.get('main', False)
model.append(component, c_in, c_out, in_y, main)
return model
def build_model(config: Union[str, Path, dict], mode: str = 'infer',
load_trained: bool = False, download: bool = False,
serialized: Optional[bytes] = None) -> Chainer:
"""Build and return the model described in corresponding configuration file."""
config = parse_config(config)
if serialized:
serialized: list = pickle.loads(serialized)
if download:
deep_download(config)
import_packages(config.get('metadata', {}).get('imports', []))
model_config = config['chainer']
model = Chainer(model_config['in'], model_config['out'], model_config.get('in_y'))
for component_config in model_config['pipe']:
if load_trained and ('fit_on' in component_config or 'in_y' in component_config):
try:
component_config['load_path'] = component_config['save_path']
except KeyError:
log.warning('No "save_path" parameter for the {} component, so "load_path" will not be renewed'
.format(component_config.get('class_name', component_config.get('ref', 'UNKNOWN'))))
if serialized and 'in' in component_config:
component_serialized = serialized.pop(0)
else:
component_serialized = None
component = from_params(component_config, mode=mode, serialized=component_serialized)
if 'in' in component_config:
c_in = component_config['in']
c_out = component_config['out']
in_y = component_config.get('in_y', None)
main = component_config.get('main', False)
model.append(component, c_in, c_out, in_y, main)
return model
def test_crossvalidation():
model_dir = 'faq'
conf_file = 'cv/cv_tfidf_autofaq.json'
download_config(conf_file)
c = test_configs_path / conf_file
model_path = download_path / model_dir
install_config(c)
deep_download(c)
shutil.rmtree(str(model_path), ignore_errors=True)
logfile = io.BytesIO(b'')
p = pexpect.popen_spawn.PopenSpawn(sys.executable + f" -m deeppavlov crossval {c} --folds 2",
timeout=None, logfile=logfile)
p.readlines()
if p.wait() != 0:
raise RuntimeError('Training process of {} returned non-zero exit code: \n{}'
.format(model_dir, logfile.getvalue().decode()))
shutil.rmtree(str(download_path), ignore_errors=True)
def test_evolving():
model_dir = 'evolution'
conf_file = 'evolution/evolve_intents_snips.json'
download_config(conf_file)
c = test_configs_path / conf_file
model_path = download_path / model_dir
install_config(c)
deep_download(c)
shutil.rmtree(str(model_path), ignore_errors=True)
logfile = io.BytesIO(b'')
p = pexpect.popen_spawn.PopenSpawn(sys.executable + f" -m deeppavlov.evolve {c} --iterations 1 --p_size 1",
timeout=None, logfile=logfile)
p.readlines()
if p.wait() != 0:
raise RuntimeError('Training process of {} returned non-zero exit code: \n{}'
.format(model_dir, logfile.getvalue().decode()))
shutil.rmtree(str(download_path), ignore_errors=True)
def test_evolving(self, model, conf_file, model_dir, mode):
if 'E' in mode:
c = test_configs_path / conf_file
model_path = download_path / model_dir
if 'IP' not in mode and 'TI' not in mode:
config_path = str(test_configs_path.joinpath(conf_file))
deep_download(['-c', config_path])
shutil.rmtree(str(model_path), ignore_errors=True)
logfile = io.BytesIO(b'')
_, exitstatus = pexpect.run(sys.executable + f" -m deeppavlov.evolve {c} --iterations 1 --p_size 1",
timeout=None, withexitstatus=True,
logfile=logfile)
if exitstatus != 0:
logfile.seek(0)
raise RuntimeError('Training process of {} returned non-zero exit code: \n{}'
.format(model_dir, ''.join((line.decode() for line in logfile.readlines()))))
shutil.rmtree(str(download_path), ignore_errors=True)
else:
pytest.skip("Unsupported mode: {}".format(mode))
def test_consecutive_training_and_interacting(self, model, conf_file, model_dir, mode):
if 'TI' in mode:
c = test_configs_path / conf_file
model_path = download_path / model_dir
if 'IP' not in mode:
config_path = str(test_configs_path.joinpath(conf_file))
install_config(config_path)
deep_download(config_path)
shutil.rmtree(str(model_path), ignore_errors=True)
logfile = io.BytesIO(b'')
p = pexpect.popen_spawn.PopenSpawn(sys.executable + " -m deeppavlov train " + str(c), timeout=None,
logfile=logfile)
p.readlines()
if p.wait() != 0:
raise RuntimeError('Training process of {} returned non-zero exit code: \n{}'
.format(model_dir, logfile.getvalue().decode()))
self.interact(c, model_dir)
shutil.rmtree(str(download_path), ignore_errors=True)
else:
pytest.skip("Unsupported mode: {}".format(mode))
def main():
args = parser.parse_args()
pipeline_config_path = find_config(args.config_path)
if args.download or args.mode == 'download':
deep_download(['-c', pipeline_config_path])
token = args.token or os.getenv('TELEGRAM_TOKEN')
if args.mode == 'train':
train_evaluate_model_from_config(pipeline_config_path)
elif args.mode == 'evaluate':
train_evaluate_model_from_config(pipeline_config_path, to_train=False, to_validate=False)
elif args.mode == 'interact':
interact_model(pipeline_config_path)
elif args.mode == 'interactbot':
if not token:
log.error('Token required: initiate -t param or TELEGRAM_BOT env var with Telegram bot token')
else:
interact_model_by_telegram(pipeline_config_path, token)
elif args.mode == 'riseapi':
start_model_server(pipeline_config_path)
elif args.mode == 'predict':
predict_on_stream(pipeline_config_path, args.batch_size, args.file_path)
elif args.mode == 'install':
install_from_config(pipeline_config_path)
'name': 'default_vocab',
'save_path': 'vocabs/token.dict',
'load_path': 'vocabs/token.dict',
'fit_on': ['utterance'],
'level': 'token',
'tokenizer': {
'name': 'split_tokenizer'
},
'main': True
}
# chainer.pipe: a list of consequently run components
vocab_config['chainer']['pipe'] = [vocab_comp_config]
json.dump(vocab_config, open("gobot/vocab_config.json", 'wt'))
""" Download "dstc2_v2" dataset, need to do only once """
deep_download(['--config', 'gobot/vocab_config.json'])
dstc2_path = deeppavlov.__path__[
0] + '/../download/dstc2' # Data was downloaded to dstc2_path
"""
Step 3: Vocabulary Building
"""
train_evaluate_model_from_config("gobot/vocab_config.json")
vocabs_path = deeppavlov.__path__[0] + '/../download/vocabs'
vocab_comp_config['in'] = ['utterance']
vocab_comp_config['out'] = ['utterance_token_indices']
vocab_config['chainer']['pipe'] = [vocab_comp_config]
vocab_config['chainer']['out'] = ['utterance_token_indices']
"""
def __init__(self, config_path, download=False): if download == True: deep_download(config_path) self.model = build_model_from_config(config_path)
def main():
args = parser.parse_args()
pipeline_config_path = find_config(args.config_path)
if args.download or args.mode == 'download':
deep_download(pipeline_config_path)
if args.mode == 'train':
train_evaluate_model_from_config(pipeline_config_path,
recursive=args.recursive,
start_epoch_num=args.start_epoch_num)
elif args.mode == 'evaluate':
train_evaluate_model_from_config(pipeline_config_path,
to_train=False,
start_epoch_num=args.start_epoch_num)
elif args.mode == 'interact':
interact_model(pipeline_config_path)
elif args.mode == 'telegram':
interact_model_by_telegram(model_config=pipeline_config_path,
token=args.token)
elif args.mode == 'msbot':
start_ms_bf_server(model_config=pipeline_config_path,
app_id=args.ms_id,
app_secret=args.ms_secret,
port=args.port,
https=args.https,
ssl_key=args.key,
ssl_cert=args.cert)
elif args.mode == 'alexa':
start_alexa_server(model_config=pipeline_config_path,
port=args.port,
https=args.https,
ssl_key=args.key,
ssl_cert=args.cert)
elif args.mode == 'alice':
start_alice_server(model_config=pipeline_config_path,
port=args.port,
https=args.https,
ssl_key=args.key,
ssl_cert=args.cert)
elif args.mode == 'riseapi':
start_model_server(pipeline_config_path,
args.https,
args.key,
args.cert,
port=args.port)
elif args.mode == 'risesocket':
start_socket_server(pipeline_config_path,
args.socket_type,
port=args.port,
socket_file=args.socket_file)
elif args.mode == 'agent-rabbit':
start_rabbit_service(model_config=pipeline_config_path,
service_name=args.service_name,
agent_namespace=args.agent_namespace,
batch_size=args.batch_size,
utterance_lifetime_sec=args.utterance_lifetime,
rabbit_host=args.rabbit_host,
rabbit_port=args.rabbit_port,
rabbit_login=args.rabbit_login,
rabbit_password=args.rabbit_password,
rabbit_virtualhost=args.rabbit_virtualhost)
elif args.mode == 'predict':
predict_on_stream(pipeline_config_path, args.batch_size,
args.file_path)
elif args.mode == 'install':
install_from_config(pipeline_config_path)
elif args.mode == 'crossval':
if args.folds < 2:
log.error('Minimum number of Folds is 2')
else:
calc_cv_score(pipeline_config_path,
n_folds=args.folds,
is_loo=False)
import argparse
from deeppavlov.models.morpho_tagger.common import predict_with_model
from deeppavlov.deep import find_config
from deeppavlov.download import deep_download
parser = argparse.ArgumentParser()
parser.add_argument("config_path", help="path to file with prediction configuration")
parser.add_argument("-d", "--download", action="store_true", help="download model components")
if __name__ == "__main__":
args = parser.parse_args()
config_path = find_config(args.config_path)
if args.download:
deep_download(['-c', config_path])
predict_with_model(config_path)
def train_evaluate_model_from_config(config: [str, Path, dict], iterator=None, *,
to_train=True, to_validate=True, download=False,
start_epoch_num=0, recursive=False) -> Dict[str, Dict[str, float]]:
"""Make training and evaluation of the model described in corresponding configuration file."""
config = parse_config(config)
if download:
deep_download(config)
if to_train and recursive:
for subconfig in get_all_elems_from_json(config['chainer'], 'config_path'):
log.info(f'Training "{subconfig}"')
train_evaluate_model_from_config(subconfig, download=False, recursive=True)
import_packages(config.get('metadata', {}).get('imports', []))
if iterator is None:
try:
data = read_data_by_config(config)
except ConfigError as e:
to_train = False
log.warning(f'Skipping training. {e.message}')
else:
iterator = get_iterator_from_config(config, data)
train_config = {
'metrics': ['accuracy'],
'validate_best': to_validate,
'test_best': True,
'show_examples': False
}
try:
train_config.update(config['train'])
except KeyError:
log.warning('Train config is missing. Populating with default values')
in_y = config['chainer'].get('in_y', ['y'])
if isinstance(in_y, str):
in_y = [in_y]
if isinstance(config['chainer']['out'], str):
config['chainer']['out'] = [config['chainer']['out']]
metrics_functions = _parse_metrics(train_config['metrics'], in_y, config['chainer']['out'])
if to_train:
model = fit_chainer(config, iterator)
if callable(getattr(model, 'train_on_batch', None)):
_train_batches(model, iterator, train_config, metrics_functions, start_epoch_num=start_epoch_num)
model.destroy()
res = {}
if iterator is not None and (train_config['validate_best'] or train_config['test_best']):
model = build_model(config, load_trained=to_train)
log.info('Testing the best saved model')
if train_config['validate_best']:
report = {
'valid': _test_model(model, metrics_functions, iterator,
train_config.get('batch_size', -1), 'valid',
show_examples=train_config['show_examples'])
}
res['valid'] = report['valid']['metrics']
print(json.dumps(report, ensure_ascii=False))
if train_config['test_best']:
report = {
'test': _test_model(model, metrics_functions, iterator,
train_config.get('batch_size', -1), 'test',
show_examples=train_config['show_examples'])
}
res['test'] = report['test']['metrics']
print(json.dumps(report, ensure_ascii=False))
model.destroy()
return res
def main():
args = parser.parse_args()
pipeline_config_path = find_config(args.config_path)
https = args.https
ssl_key = args.key
ssl_cert = args.cert
if args.download or args.mode == 'download':
deep_download(pipeline_config_path)
multi_instance = args.multi_instance
stateful = args.stateful
if args.mode == 'train':
train_evaluate_model_from_config(pipeline_config_path,
recursive=args.recursive,
start_epoch_num=args.start_epoch_num)
elif args.mode == 'evaluate':
train_evaluate_model_from_config(pipeline_config_path,
to_train=False,
start_epoch_num=args.start_epoch_num)
elif args.mode == 'interact':
interact_model(pipeline_config_path)
elif args.mode == 'interactbot':
token = args.token
interact_model_by_telegram(
model_config=pipeline_config_path,
token=token,
default_skill_wrap=not args.no_default_skill)
elif args.mode == 'interactmsbot':
ms_id = args.ms_id
ms_secret = args.ms_secret
run_ms_bf_default_agent(model_config=pipeline_config_path,
app_id=ms_id,
app_secret=ms_secret,
multi_instance=multi_instance,
stateful=stateful,
port=args.port,
https=https,
ssl_key=ssl_key,
ssl_cert=ssl_cert,
default_skill_wrap=not args.no_default_skill)
elif args.mode == 'alexa':
run_alexa_default_agent(model_config=pipeline_config_path,
multi_instance=multi_instance,
stateful=stateful,
port=args.port,
https=https,
ssl_key=ssl_key,
ssl_cert=ssl_cert,
default_skill_wrap=not args.no_default_skill)
elif args.mode == 'riseapi':
alice = args.api_mode == 'alice'
if alice:
start_alice_server(pipeline_config_path,
https,
ssl_key,
ssl_cert,
port=args.port)
else:
start_model_server(pipeline_config_path,
https,
ssl_key,
ssl_cert,
port=args.port)
elif args.mode == 'predict':
predict_on_stream(pipeline_config_path, args.batch_size,
args.file_path)
elif args.mode == 'install':
install_from_config(pipeline_config_path)
elif args.mode == 'crossval':
if args.folds < 2:
log.error('Minimum number of Folds is 2')
else:
n_folds = args.folds
calc_cv_score(pipeline_config_path, n_folds=n_folds, is_loo=False)
def train_evaluate_model_from_config(
config: Union[str, Path, dict],
iterator: Union[DataLearningIterator, DataFittingIterator] = None,
*,
to_train: bool = True,
evaluation_targets: Optional[Iterable[str]] = None,
to_validate: Optional[bool] = None,
download: bool = False,
start_epoch_num: Optional[int] = None,
recursive: bool = False) -> Dict[str, Dict[str, float]]:
"""Make training and evaluation of the model described in corresponding configuration file."""
config = parse_config(config)
if download:
deep_download(config)
if to_train and recursive:
for subconfig in get_all_elems_from_json(config['chainer'],
'config_path'):
log.info(f'Training "{subconfig}"')
train_evaluate_model_from_config(subconfig,
download=False,
recursive=True)
import_packages(config.get('metadata', {}).get('imports', []))
if iterator is None:
try:
data = read_data_by_config(config)
except ConfigError as e:
to_train = False
log.warning(f'Skipping training. {e.message}')
else:
iterator = get_iterator_from_config(config, data)
if 'train' not in config:
log.warning('Train config is missing. Populating with default values')
train_config = config.get('train')
if start_epoch_num is not None:
train_config['start_epoch_num'] = start_epoch_num
if 'evaluation_targets' not in train_config and (
'validate_best' in train_config or 'test_best' in train_config):
log.warning(
'"validate_best" and "test_best" parameters are deprecated.'
' Please, use "evaluation_targets" list instead')
train_config['evaluation_targets'] = []
if train_config.pop('validate_best', True):
train_config['evaluation_targets'].append('valid')
if train_config.pop('test_best', True):
train_config['evaluation_targets'].append('test')
trainer_class = get_model(train_config.pop('class_name', 'nn_trainer'))
trainer = trainer_class(config['chainer'], **train_config)
if to_train:
trainer.train(iterator)
res = {}
if iterator is not None:
if to_validate is not None:
if evaluation_targets is None:
log.warning(
'"to_validate" parameter is deprecated and will be removed in future versions.'
' Please, use "evaluation_targets" list instead')
evaluation_targets = ['test']
if to_validate:
evaluation_targets.append('valid')
else:
log.warn(
'Both "evaluation_targets" and "to_validate" parameters are specified.'
' "to_validate" is deprecated and will be ignored')
res = trainer.evaluate(iterator,
evaluation_targets,
print_reports=True)
trainer.get_chainer().destroy()
res = {k: v['metrics'] for k, v in res.items()}
return res
def main():
args = parser.parse_args()
pipeline_config_path = find_config(args.config_path)
if args.download or args.mode == 'download':
deep_download(['-c', pipeline_config_path])
token = args.token or os.getenv('TELEGRAM_TOKEN')
ms_id = args.ms_id or os.getenv('MS_APP_ID')
ms_secret = args.ms_secret or os.getenv('MS_APP_SECRET')
multi_instance = args.multi_instance
stateful = args.stateful
if args.mode == 'train':
train_evaluate_model_from_config(pipeline_config_path)
elif args.mode == 'evaluate':
train_evaluate_model_from_config(pipeline_config_path,
to_train=False,
to_validate=False)
elif args.mode == 'interact':
interact_model(pipeline_config_path)
elif args.mode == 'interactbot':
if not token:
log.error(
'Token required: initiate -t param or TELEGRAM_BOT env var with Telegram bot token'
)
else:
interact_model_by_telegram(pipeline_config_path, token)
elif args.mode == 'interactmsbot':
if not ms_id:
log.error(
'Microsoft Bot Framework app id required: initiate -i param '
'or MS_APP_ID env var with Microsoft app id')
elif not ms_secret:
log.error(
'Microsoft Bot Framework app secret required: initiate -s param '
'or MS_APP_SECRET env var with Microsoft app secret')
else:
run_ms_bf_default_agent(model_config_path=pipeline_config_path,
app_id=ms_id,
app_secret=ms_secret,
multi_instance=multi_instance,
stateful=stateful)
elif args.mode == 'riseapi':
alice = args.api_mode == 'alice'
https = args.https
ssl_key = args.key
ssl_cert = args.cert
start_model_server(pipeline_config_path, alice, https, ssl_key,
ssl_cert)
elif args.mode == 'predict':
predict_on_stream(pipeline_config_path, args.batch_size,
args.file_path)
elif args.mode == 'install':
install_from_config(pipeline_config_path)
elif args.mode == 'crossval':
if args.folds < 2:
log.error('Minimum number of Folds is 2')
else:
n_folds = args.folds
calc_cv_score(pipeline_config_path=pipeline_config_path,
n_folds=n_folds,
is_loo=False)
import argparse
from deeppavlov.core.common.file import find_config
from deeppavlov.download import deep_download
from deeppavlov.models.morpho_tagger.common import predict_with_model
parser = argparse.ArgumentParser()
parser.add_argument("config_path",
help="path to file with prediction configuration")
parser.add_argument("-d",
"--download",
action="store_true",
help="download model components")
if __name__ == "__main__":
args = parser.parse_args()
config_path = find_config(args.config_path)
if args.download:
deep_download(config_path)
predict_with_model(config_path)
