def _extract_tracker(self, pipeline, verbose=True):
if verbose:
print("Building tracker...")
tracker = Tracker()
tracker.build(pipeline)
# for index in list(tracker.keys()):
# if tracker[index].source != Parameters.DUMMY_INJECTER_SOURCE:
# del tracker[index]
return tracker
def dialogue_generator_batch(argv):
"""dialogue_generator
arguments: <tracker-file> <batch-size> <output-path>
"""
from dice.evaluation import Tracker
from dice.evaluation import DialogueGenerator
import pandas as pd
tracker_file, batch_size, output_path = argv
tracker = Tracker()
tracker.load(tracker_file)
generator = DialogueGenerator(tracker)
df = generator.generate_batch(int(batch_size))
df.to_csv(output_path)
def pair_sampler(argv):
"""pair_sampler
arguments: <tracker-file> <amount> <save-path>
"""
from dice.evaluation import Tracker, PairSampler
tracker_file, amount, save_path = argv
sampler = PairSampler(Tracker(tracker_file))
sampler.process(save_path, int(amount))
def objective(args):
trackers = list()
for folder in self.folders:
pipeline = Pipeline(
folder,
reduce(lambda x, y: dict(x, **y), (args, {
"log": ""
})))
pipeline.load()
if feature == "evidence":
pipeline.step_detective()
if feature == "confidence":
pipeline.step_assigner()
tracker = Tracker()
tracker.build(pipeline)
trackers.append(tracker)
PairEvaluator.FEATURE = feature
return PairEvaluator(self.annotation_file, *trackers).evaluate()
def dialogue_generator(argv):
"""dialogue_generator
arguments: <tracker-file> <script>
"""
from dice.evaluation import Tracker
from dice.evaluation import DialogueGenerator
tracker_file, script = argv
tracker = Tracker()
tracker.load(tracker_file)
generator = DialogueGenerator(tracker)
if script == "typical":
script = DialogueGenerator.TYPICAL_SCRIPT
elif script == "plausible":
script = DialogueGenerator.PLAUSIBLE_SCRIPT
elif script == "salient":
script = DialogueGenerator.SALIENT_SCRIPT
elif script == "remarkable":
script = DialogueGenerator.REMARKABLE_SCRIPT
print(generator.generate(script)["corrected"])
def objective(args):
pipeline = Pipeline(inputs_folder, args)
Parameters.process(**args)
if feature == "evidence":
pipeline.load_detective()
# pipeline.step_detective()
if feature == "confidence":
bulk_pipeline = BulkPipeline(inputs_folder, partition)
if os.path.isdir(BulkTuner.BULK_TUNER_FOLDER):
shutil.rmtree(BulkTuner.BULK_TUNER_FOLDER)
bulk_pipeline.process(BulkTuner.BULK_TUNER_FOLDER, int(n_jobs))
del bulk_pipeline
assignment = BulkGatherer(
BulkTuner.BULK_TUNER_FOLDER).gather(False)
pipeline.set_assignment(assignment)
tracker = Tracker()
tracker.build(pipeline)
PairEvaluator.FEATURE = feature
PairEvaluator.CONFIDENCE = .5
print(PairEvaluator(self.annotation_file, tracker).evaluate(True))
return PairEvaluator(self.annotation_file, tracker).evaluate()
def tracker(argv):
"""tracker
arguments: <inputs-folder> <save-path>
"""
from dice import Inputs
from dice.evaluation import Tracker
inputs_folder, save_path = argv
tracker = Tracker()
tracker.build(Inputs(inputs_folder, load=True))
tracker.save(save_path)
def extend(self, subject, folder, verbose=True):
if verbose:
print("Extending '{}'".format(subject))
candidates = self._generate_candidates(subject, verbose)
if verbose:
print("Adding", len(candidates), "facts.")
if len(candidates) > 0:
pipeline = self._init_pipeline(folder, subject, candidates)
self._extend_inputs(subject, pipeline, verbose)
tracker = self._extract_tracker(pipeline, verbose)
else:
pipeline = Pipeline(folder, dict())
tracker = Tracker()
if os.path.isfile("embedder-tmp-" + slugify(subject) + ".tsv"):
os.system("rm " + "embedder-tmp-" + slugify(subject) + ".tsv")
if os.path.isfile("entailer-tmp-" + slugify(subject) + ".tsv"):
os.system("rm " + "entailer-tmp-" + slugify(subject) + ".tsv")
return tracker
def pair_evaluator(argv):
"""pair_evaluator
arguments: <annotation-file> <feature> <confidence> <tracker-file>+
"""
from dice.evaluation import Tracker, PairEvaluator
from dice.constants import Dimensions
annotation_file, feature, confidence, *tracker_files = argv
PairEvaluator.FEATURE = feature
PairEvaluator.CONFIDENCE = float(confidence)
evaluator = PairEvaluator(annotation_file,
*[Tracker(f) for f in tracker_files])
print(" " * 8 + "\t ppref\t size")
for dimension, results in evaluator.evaluate(details=True).items():
if dimension == -1:
print("Overall \t", round(1 - results["mae"], 2), "\t",
results["n"])
else:
print(Dimensions.label(dimension), "\t",
round(1 - results["mae"], 2), "\t", results["n"])
def bulk_process(argv):
"""bulk_process
arguments: <inputs-folder> <bulk-folder> <n-jobs> <partition-file> <tracker-path> <verbose> <notify>
"""
from dice.process import BulkPipeline
from dice.process import BulkPipelineTask
from dice.process import BulkGatherer
from dice import Inputs
from dice.evaluation import Tracker
from dice.misc import notify
inputs_folder, bulk_folder, n_jobs, partition_file, tracker_path, verbose, do_notify = argv
partition = list()
with open(partition_file) as file:
for line in file.readlines():
partition.append(list(map(int, line.strip().split("\t"))))
verbose = verbose == "True"
pipeline = BulkPipeline(inputs_folder, partition, **{})
pipeline.process(bulk_folder, int(n_jobs), verbose, False)
if verbose:
print("Gathering assignment...")
inputs = Inputs(inputs_folder)
inputs.set_assignment(BulkGatherer(bulk_folder).gather())
if verbose:
print("Gathering tracker...")
tracker = Tracker()
tracker.build(inputs)
tracker.save(tracker_path)
if do_notify == "True":
notify(
"Bulk Process", """Finished processing for the following arguments:
inputs folder: {inputs_folder}
bulk folder: {bulk_folder}
n jobs: {n_jobs}
partition file: {partition_file}
tracker path: {tracker_path}
""".format(inputs_folder=inputs_folder,
bulk_folder=bulk_folder,
n_jobs=n_jobs,
partition_file=partition_file,
tracker_path=tracker_path))