def main():
parser = argparse.ArgumentParser("Generation demo.")
parser.add_argument("src_vocab", type=Path)
parser.add_argument("tgt_vocab", type=Path)
parser.add_argument("checkpoint_dir", type=Path)
args = parser.parse_args()
source_vocab = plum.load(args.src_vocab)
target_vocab = plum.load(args.tgt_vocab)
model = load_model(args.checkpoint_dir)
input_example = [
"<sos>", "EATTYPE_N/A", "NEAR_Crowne_Plaza_Hotel", "AREA_city_centre",
"FAMILYFRIENDLY_no", "CUSTOMERRATING_N/A", "PRICERANGE_N/A",
"FOOD_N/A", "NAME_Browns_Cambridge", "<eos>"
]
encoder_inputs = {"source_inputs": seq2tsr(input_example, source_vocab)}
encoder_state = model.encode(encoder_inputs)
print("Greedy Decoding")
print("===============")
print()
greedy_search = GreedySearch(max_steps=100, vocab=target_vocab)
greedy_search(model.decoder, encoder_state)
for out in greedy_search.output():
print(" ".join(out))
print()
print("Beam Decoding (beam size=8, showing top 3)")
print("==========================================")
print()
beam_search = BeamSearch(max_steps=100, vocab=target_vocab, beam_size=10)
beam_search(model.decoder, encoder_state)
for out in beam_search.output(n_best=3)[0]:
print(" ".join(out))
print()
print("Ancestral Sampling (samples=10, showing top 3)")
print("==============================================")
print()
ancestral_sampler = AncestralSampler(max_steps=100,
vocab=target_vocab,
samples=10)
ancestral_sampler(model.decoder, encoder_state)
for out in ancestral_sampler.output(n_best=3)[0]:
print(" ".join(out))
print()
print("Noise Injection Sampling (samples=10, showing top 3)")
print("====================================================")
print()
npad_search = GreedyNPAD(max_steps=100,
vocab=target_vocab,
samples=10,
std=1.0)
npad_search(model.decoder, encoder_state)
for out in npad_search.output(n_best=3)[0]:
print(" ".join(out))
print()
def run(self, env, verbose=False):
output_path = env["proj_dir"] / "output" / self.filename
output_path.parent.mkdir(exist_ok=True, parents=True)
if self.checkpoint is None:
ckpt = self._get_default_checkpoint(env)
else:
ckpt = self.checkpoint
if ckpt is None:
raise RuntimeError("No checkpoints found!")
ckpt_path = env["checkpoints"][ckpt]["path"]
if verbose:
print("Loading model from {}".format(ckpt_path))
model = plum.load(ckpt_path).eval()
if env["gpu"] > -1:
model.cuda(env["gpu"])
self._gpu = env["gpu"]
with open(self.input_path, 'r') as fp, \
open(output_path, "w") as out_fp:
for line in fp:
data = json.loads(line)
gen_input = self.make_generator_inputs(data)
tokens, text = self._get_outputs(model, gen_input)
data = json.dumps({
"mr": data["mr"],
"tokens": tokens,
"text": text,
})
print(data, file=out_fp, flush=True)
def run(self, env, verbose=False):
if self.checkpoint is None:
ckpt = self._get_default_checkpoint(env)
else:
ckpt = self.checkpoint
if ckpt is None:
raise RuntimeError("No checkpoints found!")
ckpt_path = env["checkpoints"][ckpt]["path"]
if verbose:
print("Reading checkpoint from {}".format(ckpt_path))
model = plum.load(ckpt_path).eval()
self.preflight_checks(model, env, verbose=verbose)
if self.loss_function is not None:
self.loss_function.reset()
if self.metrics is not None:
self.metrics.reset()
self.reset_loggers(self.loggers)
num_batches = len(self.batches)
for step, batch in enumerate(self.batches, 1):
forward_state = model(batch)
if self.loss_function is not None:
self.loss_function(forward_state, batch)
if self.metrics is not None:
self.metrics(forward_state, batch)
self.apply_loggers(forward_state, batch, self.loggers)
print("eval: {}/{} loss={:7.6f}".format(
step, num_batches, self.loss_function.scalar_result()),
end="\r" if step < num_batches else "\n", flush=True)
if self.metrics is not None:
print(self.metrics.pretty_result())
result = {
"loss": {
"combined": self.loss_function.scalar_result(),
"detail": self.loss_function.compute(),
},
"metrics": self.valid_metrics.compute(),
}
self.log_results(result)
print()
self.close_loggers()
def run(self, env, verbose=False):
if self.checkpoint is None:
ckpt = self._get_default_checkpoint(env)
else:
ckpt = self.checkpoint
if ckpt is None:
raise RuntimeError("No checkpoints found!")
ckpt_path = env["checkpoints"][ckpt]["path"]
if verbose:
print("Reading checkpoint from {}".format(ckpt_path))
model = plum.load(ckpt_path).eval()
model.search_algos.update(self.searches)
if env["gpu"] > -1:
model.cuda(env["gpu"])
self.batches.gpu = env["gpu"]
if self.loss_function:
self.loss_function.reset()
if self.metrics:
self.metrics.reset()
for batch in self.batches:
state = model(batch)
if self.loss_function:
self.loss_function(state, batch)
if self.metrics:
self.metrics(state, batch)
print("loss")
pprint(self.loss_function.compute())
print()
if self.metrics:
print("metrics")
pprint(self.metrics.compute())
print()
def run(self, env, verbose=False):
output_path = env["proj_dir"] / "output" / self.filename
output_path.parent.mkdir(exist_ok=True, parents=True)
if self.checkpoint is None:
ckpt = self._get_default_checkpoint(env)
else:
ckpt = self.checkpoint
if ckpt is None:
raise RuntimeError("No checkpoints found!")
ckpt_path = env["checkpoints"][ckpt]["path"]
if verbose:
print("Loading model from {}".format(ckpt_path))
model = plum.load(ckpt_path).eval()
if env["gpu"] > -1:
model.cuda(env["gpu"])
self._gpu = env["gpu"]
samples = self.make_samples()
with open(output_path, "w") as out_fp:
for i, mr in enumerate(samples, 1):
print("{}/{}".format(i, len(samples)),
end="\r" if i < len(samples) else "\n",
flush=True)
gen_input = self.make_generator_inputs(mr)
tokens = self._get_outputs(model, gen_input)
source = preproc.mr2source_inputs(mr)
data = json.dumps({
"source": source,
"mr": mr,
"text": " ".join(tokens),
})
print(data, file=out_fp, flush=True)
def run(self, env, verbose=False):
ckpt, ckpt_md = self.get_checkpoint(env)
if verbose:
print("Reading checkpoint from {}".format(ckpt_md["path"]))
model = plum.load(ckpt_md["path"]).eval()
from plum.seq2seq.search import BeamSearch
model.search_algos["beam"] = BeamSearch(
max_steps=200,
beam_size=4,
vocab=model.search_algos["greedy"].vocab)
if env["gpu"] > -1:
if verbose:
print("Placing model and batches on device {}".format(
env["gpu"]))
model.cuda(env["gpu"])
self.batches.gpu = env["gpu"]
for batch in self.batches:
state = model(batch)
if self.reference_fields:
refs = self.apply_fields(self.reference_fields, batch)
else:
refs = None
pred = self.apply_fields(self.output_fields, state)
outputs = pred.output()
for i, output in enumerate(outputs):
if refs:
if isinstance(refs[i], (list, tuple)):
print("\n".join(refs[i]))
else:
print(refs[i])
print(postprocess(output))
print()
def __new__(cls, *args, **kwargs):
path = kwargs["path"]
return plum.load(path)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("model", type=Path)
parser.add_argument("size", type=int)
parser.add_argument("train_mrs", type=Path)
parser.add_argument("src_vocab", type=Path)
parser.add_argument("tgt_vocab", type=Path)
parser.add_argument("output", type=Path)
parser.add_argument("--max-mr-sample", type=int, default=10000)
parser.add_argument("--delex", action="store_true")
parser.add_argument("--gpu", type=int, default=-1)
parser.add_argument("--area-ckpts", type=Path)
parser.add_argument("--area-vocab", type=Path)
parser.add_argument("--eat-type-ckpts", type=Path)
parser.add_argument("--eat-type-vocab", type=Path)
parser.add_argument("--food-ckpts", type=Path)
parser.add_argument("--food-vocab", type=Path)
parser.add_argument("--family-friendly-ckpts", type=Path)
parser.add_argument("--family-friendly-vocab", type=Path)
parser.add_argument("--price-range-ckpts", type=Path)
parser.add_argument("--price-range-vocab", type=Path)
parser.add_argument("--customer-rating-ckpts", type=Path)
parser.add_argument("--customer-rating-vocab", type=Path)
args = parser.parse_args()
args.output.parent.mkdir(exist_ok=True, parents=True)
clfs = {
"area": load_model(args.area_ckpts),
"eat_type": load_model(args.eat_type_ckpts),
"food": load_model(args.food_ckpts),
"family_friendly": load_model(args.family_friendly_ckpts),
"price_range": load_model(args.price_range_ckpts),
"customer_rating": load_model(args.customer_rating_ckpts),
}
label_vocabs = {
"area": plum.load(args.area_vocab),
"eat_type": plum.load(args.eat_type_vocab),
"food": plum.load(args.food_vocab),
"family_friendly": plum.load(args.family_friendly_vocab),
"price_range": plum.load(args.price_range_vocab),
"customer_rating": plum.load(args.customer_rating_vocab),
}
generator = load_model(args.model)
if args.gpu > -1:
generator.cuda(args.gpu)
for m in clfs.values():
m.cuda(args.gpu)
src_vocab = plum.load(args.src_vocab)
tgt_vocab = plum.load(args.tgt_vocab)
counts, thresholds = count_fields(args.train_mrs, args.size)
total_accepted = 0
total_rejected = 0
num_mr_samples = 0
finish_round = False
found = set()
with args.output.open("w") as fp:
while num_mr_samples < args.max_mr_sample and not finish_round:
num_mr_samples += 1
label_sample = draw_samples(counts[args.size], args.size)
gen_inputs = make_generator_input(label_sample, src_vocab,
gpu=args.gpu)
encoder_state = generator.encode(gen_inputs)
search = plum.seq2seq.search.GreedyNPAD(
max_steps=100, std=1.0, samples=200, vocab=tgt_vocab)
search(generator.decoder, encoder_state)
candidate_descriptions = search.output(n_best=20)[0]
clf_input = search2inputs(candidate_descriptions, tgt_vocab,
args.gpu)
candidates = filter_candidates(candidate_descriptions, clf_input,
clfs, label_vocabs)
for desc, mr in candidates:
pretty = postedit.detokenize(desc)
if pretty in found:
total_rejected += 1
continue
found.add(pretty)
data = {
"sequence": {
"mrs": labels2inputs(mr),
"tokens": desc[:-1]
},
"labels": mr,
}
print(json.dumps(data), file=fp)
total_accepted += 1
pred_mr_size = count_active_fields(mr)
for field, value in mr.items():
counts[pred_mr_size][field][value] += 1
finish_round, num_complete, num_total = check_terminate(
counts[args.size], thresholds[args.size])
print("{} / {} accept={} reject={} samples-this-round={}".format(
num_complete, num_total, total_accepted, total_rejected,
num_mr_samples),
end="\r" if not finish_round else "\n", flush=True)
print()
print_counts(counts, thresholds, args.size)
def load_model(ckpt_dir):
meta = json.loads((ckpt_dir / "ckpt.metadata.json").read_text())
model_path = ckpt_dir / meta['optimal_checkpoint']
return plum.load(model_path).eval()
def run(self, env, verbose=False):
output_path = env["proj_dir"] / "output" / self.filename
output_path.parent.mkdir(exist_ok=True, parents=True)
if self.checkpoint is None:
ckpt = self._get_default_checkpoint(env)
else:
ckpt = self.checkpoint
if ckpt is None:
raise RuntimeError("No checkpoints found!")
ckpt_path = env["checkpoints"][ckpt]["path"]
if verbose:
print("Loading model from {}".format(ckpt_path))
model = plum.load(ckpt_path).eval()
if env["gpu"] > -1:
model.cuda(env["gpu"])
self._gpu = env["gpu"]
with output_path.open("w") as fp:
field_subsets = self._field_subsets_iter(self.mr_size)
for i, field_subset in enumerate(field_subsets, 1):
print("slot subset {}/{}".format(i, self.total_subsets))
if verbose:
print(" slots: {}".format(field_subset))
total_mrs = self.total_settings(field_subset)
batch = []
inst_iter = self._instance_iter(field_subset)
for j, labels in enumerate(inst_iter, 1):
print("setting {}/{}".format(j, total_mrs),
end="\r" if j < total_mrs else "\n",
flush=True)
batch.append(labels)
if len(batch) == self.batch_size:
output_tokens, output_strings = self._get_outputs(
model, batch)
for labels, tokens, string in zip(
batch, output_tokens, output_strings):
data = json.dumps({
"labels": labels,
"tokens": tokens,
"text": string
})
print(data, file=fp)
batch = []
if len(batch) > 0:
output_tokens, output_strings = self._get_outputs(
model, batch)
for labels, tokens, string in zip(batch, output_tokens,
output_strings):
data = json.dumps({
"labels": labels,
"tokens": tokens,
"text": string
})
print(data, file=fp)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("model", type=Path)
parser.add_argument("size", type=int)
parser.add_argument("train_mrs", type=Path)
parser.add_argument("src_vocab", type=Path)
parser.add_argument("tgt_vocab", type=Path)
parser.add_argument("output", type=Path)
parser.add_argument("--max-mr-sample", type=int, default=10000)
parser.add_argument("--delex", action="store_true")
parser.add_argument("--gpu", type=int, default=-1)
args = parser.parse_args()
args.output.parent.mkdir(exist_ok=True, parents=True)
generator = load_model(args.model)
if args.gpu > -1:
generator.cuda(args.gpu)
src_vocab = plum.load(args.src_vocab)
tgt_vocab = plum.load(args.tgt_vocab)
counts, thresholds = count_fields(args.train_mrs, args.size)
total_accepted = 0
total_rejected = 0
num_mr_samples = 0
finish_round = False
found = set()
with args.output.open("w") as fp:
while num_mr_samples < args.max_mr_sample and not finish_round:
num_mr_samples += 1
label_sample = draw_samples(counts[args.size], args.size)
gen_inputs = make_generator_input(label_sample,
src_vocab,
gpu=args.gpu)
encoder_state = generator.encode(gen_inputs)
search = plum.seq2seq.search.GreedyNPAD(max_steps=100,
std=1.0,
samples=200,
vocab=tgt_vocab)
search(generator.decoder, encoder_state)
candidate_descriptions = search.output(n_best=20)[0]
for desc in candidate_descriptions:
pretty = postedit.detokenize(desc)
if pretty in found:
total_rejected += 1
continue
if pretty.count("' ' '") > 0:
total_rejected += 1
continue
pred_labels = rule_classify(pretty)
if pred_labels["name"] is None:
total_rejected += 1
continue
found.add(pretty)
data = {
"sequence": {
"mrs": labels2inputs(pred_labels),
"tokens": desc[:-1]
},
"labels": pred_labels,
}
print(json.dumps(data), file=fp)
# print(label_sample)
# print(pretty)
# print({f: v for f, v in rule_classify(pretty).items()
# if v != "N/A"})
# print()
# print(data)
# input()
total_accepted += 1
pred_mr_size = count_active_fields(pred_labels)
for field, value in pred_labels.items():
#if value == "N/A":
# continue
counts[pred_mr_size][field][value] += 1
finish_round, num_complete, num_total = check_terminate(
counts[args.size], thresholds[args.size])
print("{} / {} accept={} reject={} samples-this-round={}".format(
num_complete, num_total, total_accepted, total_rejected,
num_mr_samples),
end="\r" if not finish_round else "\n",
flush=True)
print()
print_counts(counts, thresholds, args.size)
