def main(prog: str = None,
subcommand_overrides: Dict[str, Subcommand] = {}) -> None:
"""
The :mod:`~allennlp.run` command only knows about the registered classes in the ``allennlp``
codebase. In particular, once you start creating your own ``Model`` s and so forth, it won't
work for them, unless you use the ``--include-package`` flag.
"""
parser = ArgumentParserWithDefaults(description="Run AllenNLP",
usage="%(prog)s",
prog=prog)
parser.add_argument("--version",
action="version",
version="%(prog)s " + __version__)
subparsers = parser.add_subparsers(title="Commands", metavar="")
subcommands = {
# Default commands
"configure": Configure(),
"train": Train(),
"evaluate": Evaluate(),
"predict": Predict(),
"make-vocab": MakeVocab(),
"elmo": Elmo(),
"fine-tune": FineTune(),
"dry-run": DryRun(),
"test-install": TestInstall(),
"find-lr": FindLearningRate(),
"print-results": PrintResults(),
# Superseded by overrides
**subcommand_overrides,
}
for name, subcommand in subcommands.items():
subparser = subcommand.add_subparser(name, subparsers)
# configure doesn't need include-package because it imports
# whatever classes it needs.
if name != "configure":
subparser.add_argument(
"--include-package",
type=str,
action="append",
default=[],
help="additional packages to include",
)
args = parser.parse_args()
# If a subparser is triggered, it adds its work as `args.func`.
# So if no such attribute has been added, no subparser was triggered,
# so give the user some help.
if "func" in dir(args):
# Import any additional modules needed (to register custom classes).
for package_name in getattr(args, "include_package", ()):
import_submodules(package_name)
args.func(args)
else:
parser.print_help()
def main(prog: str = None,
model_overrides: Dict[str, DemoModel] = {},
predictor_overrides: Dict[str, str] = {},
subcommand_overrides: Dict[str, Subcommand] = {}) -> None:
"""
The :mod:`~allennlp.run` command only knows about the registered classes in the ``allennlp``
codebase. In particular, once you start creating your own ``Model`` s and so forth, it won't
work for them, unless you use the ``--include-package`` flag available for most commands.
"""
# pylint: disable=dangerous-default-value
# TODO(mattg): document and/or remove the `predictor_overrides` and `model_overrides` commands.
# The `--predictor` option for the `predict` command largely removes the need for
# `predictor_overrides`, and I think the simple server largely removes the need for
# `model_overrides`, and maybe the whole `serve` command as a public API (we only need that
# path for demo.allennlp.org, and it's not likely anyone else would host that particular demo).
parser = argparse.ArgumentParser(description="Run AllenNLP",
usage='%(prog)s',
prog=prog)
subparsers = parser.add_subparsers(title='Commands', metavar='')
subcommands = {
# Default commands
"train": Train(),
"evaluate": Evaluate(),
"predict": Predict(predictor_overrides),
"serve": Serve(model_overrides),
"make-vocab": MakeVocab(),
"elmo": Elmo(),
"fine-tune": FineTune(),
# Superseded by overrides
**subcommand_overrides
}
for name, subcommand in subcommands.items():
subparser = subcommand.add_subparser(name, subparsers)
subparser.add_argument('--include-package',
type=str,
action='append',
default=[],
help='additional packages to include')
args = parser.parse_args()
# Import any additional modules needed (to register custom classes).
for package_name in args.include_package:
import_submodules(package_name)
# If a subparser is triggered, it adds its work as `args.func`.
# So if no such attribute has been added, no subparser was triggered,
# so give the user some help.
if 'func' in dir(args):
args.func(args)
else:
parser.print_help()
def main(prog: str = None,
subcommand_overrides: Dict[str, Subcommand] = {}) -> None:
"""
The :mod:`~allennlp.run` command only knows about the registered classes in the ``allennlp``
codebase. In particular, once you start creating your own ``Model`` s and so forth, it won't
work for them, unless you use the ``--include-package`` flag.
"""
# pylint: disable=dangerous-default-value
parser = argparse.ArgumentParser(description="Run AllenNLP", usage='%(prog)s', prog=prog)
parser.add_argument('--version', action='version', version='%(prog)s ' + __version__)
subparsers = parser.add_subparsers(title='Commands', metavar='')
subcommands = {
# Default commands
"configure": Configure(),
"train": Train(),
"train_multitask": TrainMultiTask(), # includes the auxillary citation section prediction task
"train_multitask_2": TrainMultiTask2(), # includes both tasks
"evaluate": Evaluate(),
"predict": Predict(),
"make-vocab": MakeVocab(),
"elmo": Elmo(),
"fine-tune": FineTune(),
"dry-run": DryRun(),
"test-install": TestInstall(),
# Superseded by overrides
**subcommand_overrides
}
for name, subcommand in subcommands.items():
subparser = subcommand.add_subparser(name, subparsers)
# configure doesn't need include-package because it imports
# whatever classes it needs.
if name != "configure":
subparser.add_argument('--include-package',
type=str,
action='append',
default=[],
help='additional packages to include')
args = parser.parse_args()
# If a subparser is triggered, it adds its work as `args.func`.
# So if no such attribute has been added, no subparser was triggered,
# so give the user some help.
if 'func' in dir(args):
# Import any additional modules needed (to register custom classes).
for package_name in getattr(args, 'include_package', ()):
try:
import_submodules(package_name)
except TypeError:
import pdb; pdb.set_trace()
args.func(args)
else:
parser.print_help()
def test_make_vocab_args(self):
parser = argparse.ArgumentParser(description="Testing")
subparsers = parser.add_subparsers(title='Commands', metavar='')
MakeVocab().add_subparser('make-vocab', subparsers)
for serialization_arg in ["-s", "--serialization-dir"]:
raw_args = ["make-vocab", "path/to/params", serialization_arg, "serialization_dir"]
args = parser.parse_args(raw_args)
assert args.func == make_vocab_from_args # pylint: disable=comparison-with-callable
assert args.param_path == "path/to/params"
assert args.serialization_dir == "serialization_dir"
def main(prog: str = None,
model_overrides: Dict[str, DemoModel] = {},
predictor_overrides: Dict[str, str] = {},
subcommand_overrides: Dict[str, Subcommand] = {}) -> None:
"""
The :mod:`~allennlp.run` command only knows about the registered classes
in the ``allennlp`` codebase. In particular, once you start creating your own
``Model`` s and so forth, it won't work for them. However, ``allennlp.run`` is
simply a wrapper around this function. To use the command line interface with your
own custom classes, just create your own script that imports all of the classes you want
and then calls ``main()``.
The default models for ``serve`` and the default predictors for ``predict`` are
defined above. If you'd like to add more or use different ones, the
``model_overrides`` and ``predictor_overrides`` arguments will take precedence over the defaults.
"""
# pylint: disable=dangerous-default-value
parser = argparse.ArgumentParser(description="Run AllenNLP", usage='%(prog)s [command]', prog=prog)
subparsers = parser.add_subparsers(title='Commands', metavar='')
subcommands = {
# Default commands
"train": Train(),
"evaluate": Evaluate(),
"predict": Predict(predictor_overrides),
"serve": Serve(model_overrides),
"make-vocab": MakeVocab(),
"elmo": Elmo(),
# Superseded by overrides
**subcommand_overrides
}
for name, subcommand in subcommands.items():
subcommand.add_subparser(name, subparsers)
# Check and warn for deprecated args.
for arg in sys.argv[1:]:
if arg in DEPRECATED_FLAGS:
logger.warning("Argument name %s is deprecated (and will likely go away at some point), "
"please use %s instead",
arg,
DEPRECATED_FLAGS[arg])
args = parser.parse_args()
# If a subparser is triggered, it adds its work as `args.func`.
# So if no such attribute has been added, no subparser was triggered,
# so give the user some help.
if 'func' in dir(args):
args.func(args)
else:
parser.print_help()
def test_make_vocab_args(self):
parser = argparse.ArgumentParser(description=u"Testing")
subparsers = parser.add_subparsers(title=u'Commands', metavar=u'')
MakeVocab().add_subparser(u'make-vocab', subparsers)
for serialization_arg in [u"-s", u"--serialization-dir"]:
raw_args = [
u"make-vocab", u"path/to/params", serialization_arg,
u"serialization_dir"
]
args = parser.parse_args(raw_args)
assert args.func == make_vocab_from_args
assert args.param_path == u"path/to/params"
assert args.serialization_dir == u"serialization_dir"
def test_make_vocab_args(self):
parser = argparse.ArgumentParser(description="Testing")
subparsers = parser.add_subparsers(title="Commands", metavar="")
MakeVocab().add_subparser("make-vocab", subparsers)
for serialization_arg in ["-s", "--serialization-dir"]:
raw_args = [
"make-vocab", "path/to/params", serialization_arg,
"serialization_dir"
]
args = parser.parse_args(raw_args)
assert args.func == make_vocab_from_args
assert args.param_path == "path/to/params"
assert args.serialization_dir == "serialization_dir"
def create_parser(
prog: str = None,
subcommand_overrides: Dict[str,
Subcommand] = None) -> argparse.ArgumentParser:
"""
Creates the argument parser for the main program.
"""
if subcommand_overrides is None:
subcommand_overrides = {}
parser = ArgumentParserWithDefaults(description="Run AllenNLP",
usage="%(prog)s",
prog=prog)
parser.add_argument("--version",
action="version",
version="%(prog)s " + __version__)
subparsers = parser.add_subparsers(title="Commands", metavar="")
subcommands = {
# Default commands
"configure": Configure(),
"train": Train(),
"evaluate": Evaluate(),
"predict": Predict(),
"make-vocab": MakeVocab(),
"elmo": Elmo(),
"fine-tune": FineTune(),
"dry-run": DryRun(),
"test-install": TestInstall(),
"find-lr": FindLearningRate(),
"print-results": PrintResults(),
# Superseded by overrides
**subcommand_overrides,
}
for name, subcommand in subcommands.items():
subparser = subcommand.add_subparser(name, subparsers)
# configure doesn't need include-package because it imports
# whatever classes it needs.
if name != "configure":
subparser.add_argument(
"--include-package",
type=str,
action="append",
default=[],
help="additional packages to include",
)
return parser
def main(prog=None, subcommand_overrides={}):
u"""
The :mod:`~allennlp.run` command only knows about the registered classes in the ``allennlp``
codebase. In particular, once you start creating your own ``Model`` s and so forth, it won't
work for them, unless you use the ``--include-package`` flag.
"""
# pylint: disable=dangerous-default-value
parser = argparse.ArgumentParser(description=u"Run AllenNLP",
usage=u'%(prog)s',
prog=prog)
parser.add_argument(u'--version', action=u'version', version=u'%(prog)s ')
subparsers = parser.add_subparsers(title=u'Commands', metavar=u'')
subcommands = {
# Default commands
u"configure": Configure(),
u"train": Train(),
u"evaluate": Evaluate(),
u"predict": Predict(),
u"make-vocab": MakeVocab(),
u"elmo": Elmo(),
u"fine-tune": FineTune(),
u"dry-run": DryRun(),
u"test-install": TestInstall(),
}
for name, subcommand in list(subcommands.items()):
subparser = subcommand.add_subparser(name, subparsers)
# configure doesn't need include-package because it imports
# whatever classes it needs.
if name != u"configure":
subparser.add_argument(u'--include-package',
type=unicode,
action=u'append',
default=[],
help=u'additional packages to include')
args = parser.parse_args()
# If a subparser is triggered, it adds its work as `args.func`.
# So if no such attribute has been added, no subparser was triggered,
# so give the user some help.
if u'func' in dir(args):
# Import any additional modules needed (to register custom classes).
for package_name in getattr(args, u'include_package', ()):
import_submodules(package_name)
args.func(args)
else:
parser.print_help()
def main(prog: str = None,
subcommand_overrides: Dict[str, Subcommand] = {}) -> None:
"""
The :mod:`~allennlp.run` command only knows about the registered classes in the ``allennlp``
codebase. In particular, once you start creating your own ``Model`` s and so forth, it won't
work for them, unless you use the ``--include-package`` flag.
"""
# pylint: disable=dangerous-default-value
parser = argparse.ArgumentParser(description="Run AllenNLP",
usage='%(prog)s',
prog=prog)
subparsers = parser.add_subparsers(title='Commands', metavar='')
subcommands = {
# Default commands
"train": Train(),
"evaluate": Evaluate(),
"predict": Predict(),
"make-vocab": MakeVocab(),
"elmo": Elmo(),
"fine-tune": FineTune(),
"dry-run": DryRun(),
# Superseded by overrides
**subcommand_overrides
}
for name, subcommand in subcommands.items():
subparser = subcommand.add_subparser(name, subparsers)
subparser.add_argument('--include-package',
type=str,
action='append',
default=[],
help='additional packages to include')
args = parser.parse_args()
# If a subparser is triggered, it adds its work as `args.func`.
# So if no such attribute has been added, no subparser was triggered,
# so give the user some help.
if 'func' in dir(args):
# Import any additional modules needed (to register custom classes).
for package_name in args.include_package:
import_submodules(package_name)
# Run a command
args.func(args)
else:
parser.print_help()
def main():
prog = "python -m allennlp.run"
subcommand_overrides = {}
# pylint: disable=dangerous-default-value
parser = argparse.ArgumentParser(description="Run AllenNLP",
usage='%(prog)s',
prog=prog)
print(parser)
subparsers = parser.add_subparsers(title='Commands', metavar='')
subcommands = {
# Default commands
"train": Train(),
"evaluate": Evaluate(),
"evaluate_mlqa": Evaluate_MLQA(),
"make-vocab": MakeVocab(),
"fine-tune": FineTune(),
# Superseded by overrides
**subcommand_overrides
}
for name, subcommand in subcommands.items():
subparser = subcommand.add_subparser(name, subparsers)
subparser.add_argument('--include-package',
type=str,
action='append',
default=[],
help='additional packages to include')
args = parser.parse_args()
# If a subparser is triggered, it adds its work as `args.func`.
# So if no such attribute has been added, no subparser was triggered,
# so give the user some help.
if 'func' in dir(args):
# Import any additional modules needed (to register custom classes).
for package_name in args.include_package:
import_submodules(package_name)
args.func(args)
else:
parser.print_help()
