def testSplitArgStr(self):
split = utils.split_arg_str("--a 10 --b foo --c \"--d bar --e 42\"")
self.assertEqual(split, ["--a", "10", "--b", "foo", "--c",
"--d bar --e 42"], "wrong split (1): %s" % ", ".join(split))
split = utils.split_arg_str("\"--a\" 10 --b foo --c --d bar --e 42")
self.assertEqual(split, ["--a", "10", "--b", "foo", "--c", "--d",
"bar", "--e", "42"], "wrong split (2): %s" % ", ".join(split))
split = utils.split_arg_str("\"--a\"\" 10\"--b foo --c --d bar --e 42")
self.assertEqual(split, ["--a", " 10", "--b", "foo", "--c", "--d",
"bar", "--e", "42"], "wrong split (2): %s" % ", ".join(split))
def testSplitArgStr(self):
split = utils.split_arg_str("--a 10 --b foo --c \"--d bar --e 42\"")
self.assertEqual(split,
["--a", "10", "--b", "foo", "--c", "--d bar --e 42"],
"wrong split (1): %s" % ", ".join(split))
split = utils.split_arg_str("\"--a\" 10 --b foo --c --d bar --e 42")
self.assertEqual(
split,
["--a", "10", "--b", "foo", "--c", "--d", "bar", "--e", "42"],
"wrong split (2): %s" % ", ".join(split))
split = utils.split_arg_str("\"--a\"\" 10\"--b foo --c --d bar --e 42")
self.assertEqual(
split,
["--a", " 10", "--b", "foo", "--c", "--d", "bar", "--e", "42"],
"wrong split (2): %s" % ", ".join(split))
def __init__(self, feature_count, arg_str):
# parse arguments
parser = argparse.ArgumentParser(
description=
"Initialize retrieval system with the specified feedback and learning mechanism.",
prog="WTALearningSystem")
parser.add_argument(
"-w",
"--init_weights",
help="Initialization method for weights (random, zero).",
required=True)
parser.add_argument("--sample_weights", default="sample_unit_sphere")
parser.add_argument("-c", "--comparison", required=True)
parser.add_argument("-f", "--comparison_args", nargs="*")
parser.add_argument("-r", "--ranker", required=True)
parser.add_argument("-s", "--ranker_args", nargs="*", default=[])
parser.add_argument("-t", "--ranker_tie", default="random")
parser.add_argument("-d", "--delta", required=True, type=str)
parser.add_argument("-a", "--alpha", required=True, type=str)
parser.add_argument("-nr", "--num_rankers", required=True, type=int)
parser.add_argument("-up", "--update", required=True, type=str)
args = vars(parser.parse_known_args(split_arg_str(arg_str))[0])
self.ranker_class = get_class(args["ranker"])
self.num_rankers = args['num_rankers']
self.ranker_args = args["ranker_args"]
self.ranker_tie = args["ranker_tie"]
self.sample_weights = args["sample_weights"]
self.init_weights = args["init_weights"]
self.feature_count = feature_count
self.ranker = self.ranker_class(self.ranker_args,
self.ranker_tie,
self.feature_count,
sample=self.sample_weights,
init=self.init_weights)
self.update = args["update"]
if "," in args["delta"]:
self.delta = np.array([float(x) for x in args["delta"].split(",")])
else:
self.delta = float(args["delta"])
if "," in args["alpha"]:
self.alpha = np.array([float(x) for x in args["alpha"].split(",")])
else:
self.alpha = float(args["alpha"])
self.comparison_class = get_class(args['comparison'])
if "comparison_args" in args and args["comparison_args"] is not None:
self.comparison_args = " ".join(args["comparison_args"])
self.comparison_args = self.comparison_args.strip("\"")
else:
self.comparison_args = None
self.comparison = self.comparison_class(self.comparison_args)
self.query_count = 0
def __init__(self, arg_str=None):
OptimizedInterleave.__init__(self, arg_str)
parser = argparse.ArgumentParser()
parser.add_argument('--allowed_leavings',
choices=['prefix_constraint',
'prefix_constraint_va'],
default='prefix_constraint_va')
parser.add_argument("--credit_va", action="store_true", default=False)
parser.add_argument("--um_class", type=str,
default="environment.FederatedClickModel")
parser.add_argument("--um_args", type=str,
default="0.2 0.1")
args = vars(parser.parse_known_args(split_arg_str(arg_str))[0])
self.allowed_leavings = getattr(self, args['allowed_leavings'])
if args["credit_va"]:
self.precompute_rank = self.precompute_rank_va
self.um_class = get_class(args["um_class"])
self.um = self.um_class(args["um_args"])
def __init__(self, arg_str):
parser = argparse.ArgumentParser(
description=
"Initialize a cascade user model with click and stop probabilities.",
prog="CascadeUserModel")
parser.add_argument("-c", "--p_click", nargs="+")
parser.add_argument("-s", "--p_stop", nargs="+")
args = vars(parser.parse_args(split_arg_str(arg_str)))
# allow arbitrary hash maps to map relevance labels to click and stop
# probabilities
p_click_str = "".join(args["p_click"]).strip("\"")
self.p_click = {}
for entry in re.split("\s*,\s*", p_click_str):
(key, value) = re.split("\s*:\s*", entry)
self.p_click[int(key)] = float(value)
self.p_stop = {}
p_stop_str = "".join(args["p_stop"]).strip("\"")
for entry in re.split("\s*,\s*", p_stop_str):
(key, value) = re.split("\s*:\s*", entry)
self.p_stop[int(key)] = float(value)