def main() -> None:
parser = argparse.ArgumentParser(
description="Runs Neural Monkey as a web server.")
parser.add_argument("--port", type=int, default=5000)
parser.add_argument("--host", type=str, default="127.0.0.1")
parser.add_argument("--configuration", type=str, required=True)
parser.add_argument("--preprocess", type=str,
required=False, default=None)
args = parser.parse_args()
print("")
if args.preprocess is not None:
preprocessing = Configuration()
preprocessing.add_argument("preprocess")
preprocessing.load_file(args.preprocess)
preprocessing.build_model()
APP.config["preprocess"] = preprocessing.model.preprocess
else:
APP.config["preprocess"] = []
exp = Experiment(config_path=args.configuration)
exp.build_model()
APP.config["experiment"] = exp
APP.run(port=args.port, host=args.host)
def main() -> None:
# pylint: disable=no-member,broad-except
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("config",
metavar="INI-FILE",
help="the configuration file of the experiment")
parser.add_argument("datasets",
metavar="INI-TEST-DATASETS",
help="the configuration of the test datasets")
parser.add_argument("-g",
"--grid",
dest="grid",
action="store_true",
help="look at the SGE variables for slicing the data")
args = parser.parse_args()
test_datasets = Configuration()
test_datasets.add_argument("test_datasets")
test_datasets.add_argument("variables", cond=lambda x: isinstance(x, list))
test_datasets.load_file(args.datasets)
test_datasets.build_model()
datasets_model = test_datasets.model
exp = Experiment(config_path=args.config)
exp.build_model()
exp.load_variables(datasets_model.variables)
if args.grid and len(datasets_model.test_datasets) > 1:
raise ValueError("Only one test dataset supported when using --grid")
for dataset in datasets_model.test_datasets:
if args.grid:
if ("SGE_TASK_FIRST" not in os.environ
or "SGE_TASK_LAST" not in os.environ
or "SGE_TASK_STEPSIZE" not in os.environ
or "SGE_TASK_ID" not in os.environ):
raise EnvironmentError(
"Some SGE environment variables are missing")
length = int(os.environ["SGE_TASK_STEPSIZE"])
start = int(os.environ["SGE_TASK_ID"]) - 1
end = int(os.environ["SGE_TASK_LAST"]) - 1
if start + length > end:
length = end - start + 1
log("Running grid task {} starting at {} with step {}".format(
start // length, start, length))
dataset = dataset.subset(start, length)
if exp.config.args.evaluation is None:
exp.run_model(dataset, write_out=True)
else:
exp.evaluate(dataset, write_out=True)
for session in exp.config.model.tf_manager.sessions:
session.close()
def main() -> None:
parser = argparse.ArgumentParser(
description="Runs Neural Monkey as a web server.")
parser.add_argument("--port", type=int, default=5000)
parser.add_argument("--host", type=str, default="127.0.0.1")
parser.add_argument("--configuration", type=str, required=True)
args = parser.parse_args()
print("")
exp = Experiment(config_path=args.configuration)
exp.build_model()
APP.config["experiment"] = exp
APP.run(port=args.port, host=args.host)
def _main() -> None:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("config", metavar="INI-FILE",
help="the configuration file for the experiment")
parser.add_argument("-s", "--set", type=str, metavar="SETTING",
action="append", dest="config_changes", default=[],
help="override an option in the configuration; the "
"syntax is [section.]option=value")
parser.add_argument("-v", "--var", type=str, metavar="VAR", default=[],
action="append", dest="config_vars",
help="set a variable in the configuration; the syntax "
"is var=value (shorthand for -s vars.var=value)")
parser.add_argument("-i", "--init", dest="init_only", action="store_true",
help="initialize the experiment directory and exit "
"without building the model")
parser.add_argument("-f", "--overwrite", action="store_true",
help="force overwriting the output directory; can be "
"used to start an experiment created with --init")
args = parser.parse_args()
args.config_changes.extend("vars.{}".format(s) for s in args.config_vars)
exp = Experiment(config_path=args.config,
config_changes=args.config_changes,
train_mode=True,
overwrite_output_dir=args.overwrite)
with open(exp.get_path("args", exp.cont_index + 1), "w") as file:
print(" ".join(shlex.quote(a) for a in sys.argv), file=file)
if args.init_only:
if exp.cont_index >= 0:
log("The experiment directory already exists.", color="red")
exit(1)
exp.config.save_file(exp.get_path("experiment.ini", 0))
copyfile(args.config, exp.get_path("original.ini", 0))
log("Experiment directory initialized.")
cmd = [os.path.basename(sys.argv[0]), "-f",
exp.get_path("experiment.ini", 0)]
log("To start experiment, run: {}".format(" ".join(shlex.quote(a)
for a in cmd)))
exit(0)
try:
exp.train()
except KeyboardInterrupt:
raise
except Exception: # pylint: disable=broad-except
log(traceback.format_exc(), color="red")
exit(1)
def _main() -> None:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("config", metavar="INI-FILE",
help="the configuration file for the experiment")
parser.add_argument("-s", "--set", type=str, metavar="SETTING",
action="append", dest="config_changes", default=[],
help="override an option in the configuration; the "
"syntax is [section.]option=value")
parser.add_argument("-v", "--var", type=str, metavar="VAR", default=[],
action="append", dest="config_vars",
help="set a variable in the configuration; the syntax "
"is var=value (shorthand for -s vars.var=value)")
parser.add_argument("-i", "--init", dest="init_only", action="store_true",
help="initialize the experiment directory and exit "
"without building the model")
parser.add_argument("-f", "--overwrite", action="store_true",
help="force overwriting the output directory; can be "
"used to start an experiment created with --init")
args = parser.parse_args()
args.config_changes.extend("vars.{}".format(s) for s in args.config_vars)
exp = Experiment(config_path=args.config,
config_changes=args.config_changes,
train_mode=True,
overwrite_output_dir=args.overwrite)
with open(exp.get_path("args", exp.cont_index + 1), "w") as file:
print(" ".join(shlex.quote(a) for a in sys.argv), file=file)
if args.init_only:
if exp.cont_index >= 0:
log("The experiment directory already exists.", color="red")
exit(1)
exp.config.save_file(exp.get_path("experiment.ini", 0))
copyfile(args.config, exp.get_path("original.ini", 0))
log("Experiment directory initialized.")
cmd = [os.path.basename(sys.argv[0]), "-f",
exp.get_path("experiment.ini", 0)]
log("To start experiment, run: {}".format(" ".join(shlex.quote(a)
for a in cmd)))
exit(0)
try:
exp.train()
except KeyboardInterrupt: # pylint: disable=try-except-raise
raise
except Exception: # pylint: disable=broad-except
log(traceback.format_exc(), color="red")
exit(1)
def __init__(self,
runs_on_features,
config_path,
vars_path,
data_series="",
src_caption_series="",
caption_series="",
alignments_series="",
bs_graph_series="bs_target",
name=None):
"""
caption_series -> GreedyRunner output_series
alignments_series -> WordAlignmentRunner output_series
bs_graph_series -> BeamSearchRunner output_series
"""
super(NeuralMonkeyModelWrapper, self).__init__(name, runs_on_features)
if not os.path.isfile(config_path):
raise ValueError("File {} does not exist.".format(config_path))
self._config_path = config_path
self._vars_path = vars_path
self._data_series = data_series
self._src_caption_series = src_caption_series
self._caption_series = caption_series
self._alignments_series = alignments_series
self._bs_graph_series = bs_graph_series
self._exp = Experiment(config_path=config_path)
self._exp.build_model()
self._exp.load_variables([vars_path])
if self._src_caption_series:
self.multimodal = True
else:
self.multimodal = False
def main() -> None:
parser = argparse.ArgumentParser(
description="Runs Neural Monkey as a web server.")
parser.add_argument("--port", type=int, default=5000)
parser.add_argument("--host", type=str, default="127.0.0.1")
parser.add_argument("--configuration", type=str, required=True)
parser.add_argument("--preprocess", type=str, required=False, default=None)
args = parser.parse_args()
print("")
if args.preprocess is not None:
preprocessing = Configuration()
preprocessing.add_argument("preprocess")
preprocessing.load_file(args.preprocess)
preprocessing.build_model()
APP.config["preprocess"] = preprocessing.model.preprocess
else:
APP.config["preprocess"] = []
exp = Experiment(config_path=args.configuration)
exp.build_model()
APP.config["experiment"] = exp
APP.run(port=args.port, host=args.host)
def _reverse_gradient(x: tf.Tensor) -> tf.Tensor:
"""Flips the sign of the incoming gradient during training."""
grad_name = "gradient_reversal_{}".format(x.name)
# pylint: disable=unused-variable,invalid-name,unused-argument
@ops.RegisterGradient(grad_name)
def _flip_gradients(op, grad):
return [tf.negative(grad)]
# pylint: enable=unused-variable,invalid-name,unused-argument
from neuralmonkey.experiment import Experiment
graph = Experiment.get_current().graph
with graph.gradient_override_map({"Identity": grad_name}):
y = tf.identity(x)
return y
def _reverse_gradient(x: tf.Tensor) -> tf.Tensor:
"""Flips the sign of the incoming gradient during training."""
grad_name = "gradient_reversal_{}".format(x.name)
# pylint: disable=unused-variable,invalid-name,unused-argument
@ops.RegisterGradient(grad_name)
def _flip_gradients(op, grad):
return [tf.negative(grad)]
# pylint: enable=unused-variable,invalid-name,unused-argument
from neuralmonkey.experiment import Experiment
graph = Experiment.get_current().graph
with graph.gradient_override_map({"Identity": grad_name}):
y = tf.identity(x)
return y
def fetches(self) -> Dict[str, tf.Tensor]:
fetches = {} # type: Dict[str, tf.Tensor]
for name, bid in zip(self._names, self._batch_dims_name):
try:
fetches[name] = (
Experiment.get_current().graph.get_tensor_by_name(name))
self.batch_ids[name] = bid
except KeyError:
warn(("The tensor of name '{}' is not present in the "
"graph.").format(name))
for mpart, tname, bid in zip(self._modelparts, self._tensors,
self.batch_dims):
if not hasattr(mpart, tname):
raise ValueError("Model part {} does not have a tensor called "
"{}.".format(mpart, tname))
tensorval = getattr(mpart, tname)
fetches[tensorval.name] = tensorval
self.batch_ids[tensorval.name] = bid
return fetches
def fetches(self) -> Dict[str, tf.Tensor]:
fetches = {} # type: Dict[str, tf.Tensor]
for name, bid in zip(self._names, self._batch_dims_name):
try:
fetches[name] = (
Experiment.get_current().graph.get_tensor_by_name(name))
self.batch_ids[name] = bid
except KeyError:
warn(("The tensor of name '{}' is not present in the "
"graph.").format(name))
for mpart, tname, bid in zip(self._modelparts, self._tensors,
self.batch_dims):
if not hasattr(mpart, tname):
raise ValueError("Model part {} does not have a tensor called "
"{}.".format(mpart, tname))
tensorval = getattr(mpart, tname)
fetches[tensorval.name] = tensorval
self.batch_ids[tensorval.name] = bid
return fetches
def load(name: str,
series: List[str],
data: List[SourceSpec],
batching: BatchingScheme = None,
outputs: List[OutputSpec] = None,
buffer_size: int = None,
shuffled: bool = False) -> "Dataset":
"""Create a dataset using specification from the configuration.
The dataset provides iterators over data series. The dataset has a buffer,
which pre-fetches a given number of the data series lazily. In case the
dataset is not lazy (buffer size is `None`), the iterators are built on top
of in-memory arrays. Otherwise, the iterators operate on the data sources
directly.
Arguments:
name: The name of the dataset.
series: A list of names of data series the dataset contains.
data: The specification of the data sources for each series.
outputs: A list of output specifications.
buffer_size: The size of the buffer. If set, the dataset will be loaded
lazily into the buffer (useful for large datasets). The buffer size
specifies the number of sequences to pre-load. This is useful for
pseudo-shuffling of large data on-the-fly. Ideally, this should be
(much) larger than the batch size. Note that the buffer gets
refilled each time its size is less than half the `buffer_size`.
When refilling, the buffer gets refilled to the specified size.
"""
check_argument_types()
if batching is None:
from neuralmonkey.experiment import Experiment
log("Using default batching scheme for dataset {}.".format(name))
# pylint: disable=no-member
batch_size = Experiment.get_current().config.args.batch_size
# pylint: enable=no-member
if batch_size is None:
raise ValueError("Argument main.batch_size is not specified, "
"cannot use default batching scheme.")
batching = BatchingScheme(batch_size=batch_size)
if not series:
raise ValueError("No dataset series specified.")
if not [s for s in data if match_type(s, ReaderDef)]: # type: ignore
raise ValueError("At least one data series should be from a file")
if len(series) != len(data):
raise ValueError(
"The 'series' and 'data' lists should have the same number"
" of elements: {} vs {}.".format(len(series), len(data)))
if len(series) != len(set(series)):
raise ValueError("There are duplicate series.")
if outputs is not None:
output_sources = [o[0] for o in outputs]
if len(output_sources) != len(set(output_sources)):
raise ValueError("Multiple outputs for a single series")
log("Initializing dataset {}.".format(name))
iterators = {} # type: Dict[str, Callable[[], DataSeries]]
prep_sl = {} # type: Dict[str, Tuple[Callable, str]]
prep_dl = {} # type: Dict[str, DatasetPreprocess]
def _make_iterator(reader, files):
def itergen():
return reader(files)
return itergen
def _make_sl_iterator(src, prep):
def itergen():
return (prep(item) for item in iterators[src]())
return itergen
def _make_dl_iterator(func):
def itergen():
return func(iterators)
return itergen
# First, prepare iterators for series using file readers
for s_name, source_spec in zip(series, data):
if match_type(source_spec, ReaderDef): # type: ignore
files, reader = _normalize_readerdef(cast(ReaderDef, source_spec))
for path in files:
if not os.path.isfile(path):
raise FileNotFoundError(
"File not found. Series: {}, Path: {}"
.format(s_name, path))
iterators[s_name] = _make_iterator(reader, files)
elif match_type(source_spec, Tuple[Callable, str]):
prep_sl[s_name] = cast(Tuple[Callable, str], source_spec)
else:
assert match_type(source_spec, DatasetPreprocess) # type: ignore
prep_dl[s_name] = cast(DatasetPreprocess, source_spec)
# Second, prepare series-level preprocessors.
# Note that series-level preprocessors cannot be stacked on the dataset
# specification level.
for s_name, (preprocessor, source) in prep_sl.items():
if source not in iterators:
raise ValueError(
"Source series for series-level preprocessor nonexistent: "
"Preprocessed series '{}', source series '{}'")
iterators[s_name] = _make_sl_iterator(source, preprocessor)
# Finally, dataset-level preprocessors.
for s_name, func in prep_dl.items():
iterators[s_name] = _make_dl_iterator(func)
output_dict = None
if outputs is not None:
output_dict = {s_name: (path, writer)
for s_name, path, writer
in [_normalize_outputspec(out) for out in outputs]}
if buffer_size is not None:
return Dataset(name, iterators, batching, output_dict,
(buffer_size // 2, buffer_size), shuffled)
return Dataset(name, iterators, batching, output_dict, None, shuffled)
def __init__(self,
output_series: str,
toplevel_modelpart: ModelPart,
toplevel_tensors: List[tf.Tensor],
tensors_by_name: List[str],
tensors_by_ref: List[tf.Tensor],
batch_dims_by_name: List[int],
batch_dims_by_ref: List[int],
select_session: int = None,
single_tensor: bool = False) -> None:
"""Construct a new ``TensorRunner`` object.
Note that at this time, one must specify the toplevel objects so that
it is ensured that the graph is built. The reason for this behavior is
that the graph is constructed lazily and therefore if the tensors to
store are provided by indirect reference (name), the system does not
know early enough that it needs to create them.
Args:
output_series: The name of the generated output data series.
toplevel_modelpart: A ``ModelPart`` object that is used as the
top-level component of the model. This object should depend on
values of all the wanted tensors.
toplevel_tensors: A list of tensors that should be constructed. Use
this when the toplevel model part does not depend on this
tensor. The tensors are constructed during running this
constructor method which prints them out.
tensors_by_name: A list of tensor names to fetch. If a tensor
is not in the graph, a warning is generated and the tensor is
ignored.
tensors_by_ref: A list of tensor objects to fetch.
batch_dims_by_name: A list of integers that correspond to the
batch dimension in each wanted tensor specified by name.
batch_dims_by_ref: A list of integers that correspond to the
batch dimension in each wanted tensor specified by reference.
select_session: An optional integer specifying the session to use
in case of ensembling. When not used, tensors from all sessions
are stored. In case of a single session, this option has no
effect.
single_tensor: If `True`, it is assumed that only one tensor is to
be fetched, and the execution result will consist of this
tensor only. If `False`, the result will be a dict mapping
tensor names to NumPy arrays.
"""
check_argument_types()
BaseRunner[ModelPart].__init__(self, output_series, toplevel_modelpart)
total_tensors = len(tensors_by_name) + len(tensors_by_ref)
if single_tensor and total_tensors > 1:
raise ValueError(
"single_tensor is True, but {} tensors were given".format(
total_tensors))
self._names = tensors_by_name
self._tensors = tensors_by_ref
self._batch_dims_name = batch_dims_by_name
self._batch_dims_ref = batch_dims_by_ref
self._select_session = select_session
self._single_tensor = single_tensor
log("Blessing toplevel tensors for tensor runner:")
for tensor in toplevel_tensors:
log("Toplevel tensor: {}".format(tensor))
self._fetches = {} # type: Dict[str, tf.Tensor]
self._batch_ids = {} # type: Dict[str, int]
for name, bid in zip(self._names, self._batch_dims_name):
try:
self._fetches[name] = (
Experiment.get_current().graph.get_tensor_by_name(name))
self._batch_ids[name] = bid
except KeyError:
warn(("The tensor of name '{}' is not present in the "
"graph.").format(name))
def main() -> None:
# pylint: disable=no-member,broad-except
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("config",
metavar="INI-FILE",
help="the configuration file of the experiment")
parser.add_argument("datasets",
metavar="INI-FILE",
help="the configuration file of the experiment")
parser.add_argument("--beam",
metavar="BEAM_SIZE",
type=int,
default=10,
help="Beam size.")
parser.add_argument("--kenlm",
type=str,
default=None,
help="Path to a KenLM model arpa file.")
parser.add_argument("--lm-weight",
type=float,
help="Weight of the language model.")
parser.add_argument("--null-trail-weight",
type=float,
help="Weight of the null-trailing feature.")
parser.add_argument("--nt-ratio-weight",
type=float,
help="Weight of the null-token ratio feature.")
parser.add_argument("--out", type=str, help="Path to the output file.")
args = parser.parse_args()
test_datasets = Configuration()
test_datasets.add_argument("test_datasets")
test_datasets.add_argument("batch_size", cond=lambda x: x > 0)
test_datasets.add_argument("variables", cond=lambda x: isinstance(x, list))
test_datasets.load_file(args.datasets)
test_datasets.build_model()
datasets_model = test_datasets.model
exp = Experiment(config_path=args.config)
exp.build_model()
exp.load_variables(datasets_model.variables)
ctc_decoder = None
for runner in exp.model.runners:
if (isinstance(runner, PlainRunner)
and isinstance(runner.decoder, CTCDecoder)):
ctc_decoder = runner.decoder
break
if ctc_decoder is None:
raise ValueError(
"Was not able to detect CTC decoder in the configuration.")
logits_runner = RepresentationRunner(output_series="logits",
encoder=ctc_decoder,
attribute="logits")
exp.model.runners = [logits_runner]
dataset = datasets_model.test_datasets[0]
singleton_batches = dataset.batches(BatchingScheme(1))
print("Loading language model")
lm = NGramModel(args.kenlm)
print("LM loaded")
weights = {}
if args.lm_weight:
weights['lm_score'] = args.lm_weight
if args.null_trail_weight:
weights['null_trailing'] = args.null_trail_weight
if args.nt_ratio_weight:
weights['null_token_ratio'] = args.nt_ratio_weight
print("Weights:", weights)
i = 0
stats = []
with open(args.out, 'w') as out_file:
for sent_dataset in singleton_batches:
t1 = timeit.default_timer()
ctc_model_result = exp.run_model(sent_dataset,
write_out=False,
batch_size=1)
t2 = timeit.default_timer()
logits = np.squeeze(ctc_model_result[1]['logits'], axis=1)
t3 = timeit.default_timer()
best_hyp = decode_beam(logits,
args.beam,
ctc_decoder.vocabulary,
lm=lm,
weights=weights)
t4 = timeit.default_timer()
stats.append([len(best_hyp.tokens), t2 - t1, t4 - t3])
output = " ".join([best_hyp.tokens][0])
out_file.write(output + "\n")
if i % 10 == 0:
print("[{}] {}".format(i, output))
i += 1
with open(args.out + ".stats", 'w') as stats_file:
for line in stats:
stats_file.write("{} {:.3f} {:.3f}\n".format(*line))
for session in exp.config.model.tf_manager.sessions:
session.close()
def _get_current_experiment():
# This is needed to avoid circular imports.
from neuralmonkey.experiment import Experiment
return Experiment.get_current()
def load(name: str,
series: List[str],
data: List[SourceSpec],
batching: BatchingScheme = None,
outputs: List[OutputSpec] = None,
buffer_size: int = None,
shuffled: bool = False) -> "Dataset":
"""Create a dataset using specification from the configuration.
The dataset provides iterators over data series. The dataset has a buffer,
which pre-fetches a given number of the data series lazily. In case the
dataset is not lazy (buffer size is `None`), the iterators are built on top
of in-memory arrays. Otherwise, the iterators operate on the data sources
directly.
Arguments:
name: The name of the dataset.
series: A list of names of data series the dataset contains.
data: The specification of the data sources for each series.
outputs: A list of output specifications.
buffer_size: The size of the buffer. If set, the dataset will be loaded
lazily into the buffer (useful for large datasets). The buffer size
specifies the number of sequences to pre-load. This is useful for
pseudo-shuffling of large data on-the-fly. Ideally, this should be
(much) larger than the batch size. Note that the buffer gets
refilled each time its size is less than half the `buffer_size`.
When refilling, the buffer gets refilled to the specified size.
"""
check_argument_types()
if batching is None:
from neuralmonkey.experiment import Experiment
log("Using default batching scheme for dataset {}.".format(name))
# pylint: disable=no-member
batch_size = Experiment.get_current().config.args.batch_size
# pylint: enable=no-member
if batch_size is None:
raise ValueError("Argument main.batch_size is not specified, "
"cannot use default batching scheme.")
batching = BatchingScheme(batch_size=batch_size)
if not series:
raise ValueError("No dataset series specified.")
if not [s for s in data if match_type(s, ReaderDef)]: # type: ignore
raise ValueError("At least one data series should be from a file")
if len(series) != len(data):
raise ValueError(
"The 'series' and 'data' lists should have the same number"
" of elements: {} vs {}.".format(len(series), len(data)))
if len(series) != len(set(series)):
raise ValueError("There are duplicate series.")
if outputs is not None:
output_sources = [o[0] for o in outputs]
if len(output_sources) != len(set(output_sources)):
raise ValueError("Multiple outputs for a single series")
log("Initializing dataset {}.".format(name))
iterators = {} # type: Dict[str, Callable[[], DataSeries]]
prep_sl = {} # type: Dict[str, Tuple[Callable, str]]
prep_dl = {} # type: Dict[str, DatasetPreprocess]
def _make_iterator(reader, files):
def itergen():
return reader(files)
return itergen
def _make_sl_iterator(src, prep):
def itergen():
return (prep(item) for item in iterators[src]())
return itergen
def _make_dl_iterator(func):
def itergen():
return func(iterators)
return itergen
# First, prepare iterators for series using file readers
for s_name, source_spec in zip(series, data):
if match_type(source_spec, ReaderDef): # type: ignore
files, reader = _normalize_readerdef(cast(ReaderDef, source_spec))
for path in files:
if not os.path.isfile(path):
raise FileNotFoundError(
"File not found. Series: {}, Path: {}".format(
s_name, path))
iterators[s_name] = _make_iterator(reader, files)
elif match_type(source_spec, Tuple[Callable, str]):
prep_sl[s_name] = cast(Tuple[Callable, str], source_spec)
else:
assert match_type(source_spec, DatasetPreprocess) # type: ignore
prep_dl[s_name] = cast(DatasetPreprocess, source_spec)
# Second, prepare series-level preprocessors.
# Note that series-level preprocessors cannot be stacked on the dataset
# specification level.
for s_name, (preprocessor, source) in prep_sl.items():
if source not in iterators:
raise ValueError(
"Source series for series-level preprocessor nonexistent: "
"Preprocessed series '{}', source series '{}'")
iterators[s_name] = _make_sl_iterator(source, preprocessor)
# Finally, dataset-level preprocessors.
for s_name, func in prep_dl.items():
iterators[s_name] = _make_dl_iterator(func)
output_dict = None
if outputs is not None:
output_dict = {
s_name: (path, writer)
for s_name, path, writer in
[_normalize_outputspec(out) for out in outputs]
}
if buffer_size is not None:
return Dataset(name, iterators, batching, output_dict,
(buffer_size // 2, buffer_size), shuffled)
return Dataset(name, iterators, batching, output_dict, None, shuffled)
def main() -> None:
# pylint: disable=no-member,broad-except
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("config",
metavar="INI-FILE",
help="the configuration file of the experiment")
parser.add_argument("datasets",
metavar="INI-FILE",
help="the configuration file of the experiment")
parser.add_argument("--beam",
metavar="BEAM_SIZE",
type=int,
default=10,
help="Beam size.")
parser.add_argument("--kenlm",
type=str,
help="Path to a KenLM model arpa file.")
parser.add_argument("--prefix",
type=str,
help="Path used as a prefix of stored checkpoints.")
parser.add_argument("--lm-weight",
type=float,
help="Default weight of the language model.")
parser.add_argument("--null-trail-weight",
type=float,
help="Default weight of the null-trailing feature.")
parser.add_argument("--nt-ratio-weight",
type=float,
help="Default weight of the null-token ratio feature.")
args = parser.parse_args()
test_datasets = Configuration()
test_datasets.add_argument("test_datasets")
test_datasets.add_argument("batch_size", cond=lambda x: x > 0)
test_datasets.add_argument("variables", cond=lambda x: isinstance(x, list))
test_datasets.load_file(args.datasets)
test_datasets.build_model()
datasets_model = test_datasets.model
exp = Experiment(config_path=args.config)
exp.build_model()
exp.load_variables(datasets_model.variables)
weights = {}
if args.lm_weight is not None:
weights['lm_score'] = args.lm_weight
if args.null_trail_weight is not None:
weights['null_trailing'] = args.null_trail_weight
if args.nt_ratio_weight is not None:
weights['null_token_ratio'] = args.nt_ratio_weight
if not weights:
raise ValueError("No default weights specified, nothing to train.")
ctc_decoder = None
for runner in exp.model.runners:
if (isinstance(runner, PlainRunner)
and isinstance(runner.decoder, CTCDecoder)):
ctc_decoder = runner.decoder
break
if ctc_decoder is None:
raise ValueError(
"Was not able to detect CTC decoder in the configuration.")
print("Loading language model")
lm = NGramModel(args.kenlm)
print("LM loaded")
logits_runner = RepresentationRunner(output_series="logits",
encoder=ctc_decoder,
attribute="logits")
exp.model.runners = [logits_runner]
dataset = datasets_model.test_datasets[0]
singleton_batches = dataset.batches(BatchingScheme(1))
DATASET_SIZE = dataset.length
CHECKPOINTS = 5
CHECKPOINT_ITERS = int(DATASET_SIZE / CHECKPOINTS)
print(
"{} sentences in the dataset, checkpoint every {} sentences ({} checkpoints in total)."
.format(DATASET_SIZE, CHECKPOINT_ITERS, CHECKPOINTS))
for i, sent_dataset in enumerate(singleton_batches):
ctc_model_result = exp.run_model(sent_dataset,
write_out=False,
batch_size=1)
logits = np.squeeze(ctc_model_result[1]['logits'], axis=1)
target = ctc_model_result[2]['target'][0]
train_weights(logits, args.beam, ctc_decoder.vocabulary, target,
weights, lm)
print(
"[{}] Weights:".format(i + 1), ", ".join([
"{}: {:.3f}".format(key, value)
for key, value in weights.items()
]))
if i != 0 and (i + 1) % CHECKPOINT_ITERS == 0:
with open("{}.{}".format(args.prefix, int(i / CHECKPOINT_ITERS)),
"w") as f:
for key, value in weights.items():
f.write("{}={:.3f}\n".format(key.upper(), value))
print("\nCheckpoint saved.\n")
for session in exp.config.model.tf_manager.sessions:
session.close()
def _get_current_experiment():
# This is needed to avoid circular imports.
from neuralmonkey.experiment import Experiment
return Experiment.get_current()
def main() -> None:
# pylint: disable=no-member
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("config", metavar="INI-FILE",
help="the configuration file of the experiment")
parser.add_argument("datasets", metavar="INI-TEST-DATASETS",
help="the configuration of the test datasets")
parser.add_argument("-s", "--set", type=str, metavar="SETTING",
action="append", dest="config_changes", default=[],
help="override an option in the configuration; the "
"syntax is [section.]option=value")
parser.add_argument("-v", "--var", type=str, metavar="VAR", default=[],
action="append", dest="config_vars",
help="set a variable in the configuration; the syntax "
"is var=value (shorthand for -s vars.var=value)")
parser.add_argument("--json", type=str, help="write the evaluation "
"results to this file in JSON format")
parser.add_argument("-g", "--grid", dest="grid", action="store_true",
help="look at the SGE variables for slicing the data")
args = parser.parse_args()
datasets_model = load_runtime_config(args.datasets)
args.config_changes.extend("vars.{}".format(s) for s in args.config_vars)
exp = Experiment(config_path=args.config,
config_changes=args.config_changes)
exp.build_model()
exp.load_variables(datasets_model.variables)
if args.grid and len(datasets_model.test_datasets) > 1:
raise ValueError("Only one test dataset supported when using --grid")
results = []
for dataset in datasets_model.test_datasets:
if args.grid:
if ("SGE_TASK_FIRST" not in os.environ
or "SGE_TASK_LAST" not in os.environ
or "SGE_TASK_STEPSIZE" not in os.environ
or "SGE_TASK_ID" not in os.environ):
raise EnvironmentError(
"Some SGE environment variables are missing")
length = int(os.environ["SGE_TASK_STEPSIZE"])
start = int(os.environ["SGE_TASK_ID"]) - 1
end = int(os.environ["SGE_TASK_LAST"]) - 1
if start + length > end:
length = end - start + 1
log("Running grid task {} starting at {} with step {}"
.format(start // length, start, length))
dataset = dataset.subset(start, length)
if exp.config.args.evaluation is None:
exp.run_model(dataset, write_out=True)
else:
eval_result = exp.evaluate(dataset, write_out=True)
results.append(eval_result)
if args.json:
with open(args.json, "w") as f_out:
json.dump(results, f_out)
f_out.write("\n")
for session in exp.config.model.tf_manager.sessions:
session.close()
def main() -> None:
# pylint: disable=no-member
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("config", metavar="INI-FILE",
help="the configuration file of the experiment")
parser.add_argument("datasets", metavar="INI-TEST-DATASETS",
help="the configuration of the test datasets")
parser.add_argument("--json", type=str, help="write the evaluation "
"results to this file in JSON format")
parser.add_argument("-g", "--grid", dest="grid", action="store_true",
help="look at the SGE variables for slicing the data")
args = parser.parse_args()
datasets_model = load_runtime_config(args.datasets)
exp = Experiment(config_path=args.config)
exp.build_model()
exp.load_variables(datasets_model.variables)
if args.grid and len(datasets_model.test_datasets) > 1:
raise ValueError("Only one test dataset supported when using --grid")
results = []
for dataset in datasets_model.test_datasets:
if args.grid:
if ("SGE_TASK_FIRST" not in os.environ
or "SGE_TASK_LAST" not in os.environ
or "SGE_TASK_STEPSIZE" not in os.environ
or "SGE_TASK_ID" not in os.environ):
raise EnvironmentError(
"Some SGE environment variables are missing")
length = int(os.environ["SGE_TASK_STEPSIZE"])
start = int(os.environ["SGE_TASK_ID"]) - 1
end = int(os.environ["SGE_TASK_LAST"]) - 1
if start + length > end:
length = end - start + 1
log("Running grid task {} starting at {} with step {}"
.format(start // length, start, length))
dataset = dataset.subset(start, length)
if exp.config.args.evaluation is None:
exp.run_model(dataset,
write_out=True,
batch_size=datasets_model.batch_size)
else:
eval_result = exp.evaluate(dataset,
write_out=True,
batch_size=datasets_model.batch_size)
results.append(eval_result)
if args.json:
with open(args.json, "w") as f_out:
json.dump(results, f_out)
f_out.write("\n")
for session in exp.config.model.tf_manager.sessions:
session.close()
class NeuralMonkeyModelWrapper(ModelWrapper):
def __init__(self,
runs_on_features,
config_path,
vars_path,
data_series="",
src_caption_series="",
caption_series="",
alignments_series="",
bs_graph_series="bs_target",
name=None):
"""
caption_series -> GreedyRunner output_series
alignments_series -> WordAlignmentRunner output_series
bs_graph_series -> BeamSearchRunner output_series
"""
super(NeuralMonkeyModelWrapper, self).__init__(name, runs_on_features)
if not os.path.isfile(config_path):
raise ValueError("File {} does not exist.".format(config_path))
self._config_path = config_path
self._vars_path = vars_path
self._data_series = data_series
self._src_caption_series = src_caption_series
self._caption_series = caption_series
self._alignments_series = alignments_series
self._bs_graph_series = bs_graph_series
self._exp = Experiment(config_path=config_path)
self._exp.build_model()
self._exp.load_variables([vars_path])
if self._src_caption_series:
self.multimodal = True
else:
self.multimodal = False
def run(self, inputs, src_captions=None):
"""
Args:
inputs: A Numpy Array of inputs (feature, or image arrays).
src_captions: A list of string source captions.
Returns:
A list of dictionaries. Each dictionary contains the keys
`caption`, `alignments`, `beam_search_output_graph`.
"""
n_elems = inputs.shape[0]
# enc-dec model (runs on images)
if not self.runs_on_features:
if self._src_caption_series:
# TODO: handle multimodal translation case
pass
else:
ds = Dataset("macaque_data",
{self._data_series: lambda: inputs}, {})
# dec-only model (runs on feature maps)
else:
if self._src_caption_series:
# TODO: handle multimodal translation case
pass
else:
ds = Dataset("macaque_data",
{self._data_series: lambda: inputs}, {})
_, output_series = self._exp.run_model(dataset=ds, write_out=False)
if self._caption_series and self._caption_series in output_series:
captions = output_series[self._caption_series]
else:
captions = [None] * n_elems
if self._alignments_series and self._alignments_series in output_series:
alignments = output_series[self._alignments_series]
# WordAlignmentRunner is incompatible with beam search decoding.
if self._bs_graph_series:
alignments = None
else:
alignments = [None] * n_elems
if self._bs_graph_series and self._bs_graph_series in output_series:
bs_out = output_series[self._bs_graph_series]
graphs = []
for b in bs_out:
attns = [_transform_alignments(a) for a in b['alignments']]
graphs.append(
BeamSearchOutputGraph(scores=b['scores'],
tokens=b['tokens'],
parent_ids=b['parent_ids'],
alignments=attns))
hyps = [g.collect_hypotheses() for g in graphs]
bs_caps = [h['tokens'] for h in hyps]
bs_attns = [h['alignments'] for h in hyps]
#bs_attns = [[_transform_alignments(h) for h in hyp['alignments']] for hyp in hyps]
else:
graphs = [None] * n_elems
bs_caps = [None] * n_elems
bs_attns = [None] * n_elems
results = []
for c, a, bs_g, bs_c, bs_a in zip(captions, alignments, graphs,
bs_caps, bs_attns):
r = {}
for x in [(c, 'caption'), (a, 'alignments')]:
if x[0] is not None:
if 'greedy' not in r:
r['greedy'] = {}
r['greedy'][x[1]] = x[0]
for x in [(bs_g, 'graph'), (bs_c, 'captions'),
(bs_a, 'alignments')]:
if x[0] is not None:
if 'beam_search' not in r:
r['beam_search'] = {}
r['beam_search'][x[1]] = x[0]
results.append(r)
return results
