def p_can_see_tag(self, tag, vtags, itags):
"""
Find the subset of vtags that maximizes the p(x|subset_vtags)
and use that for the value.
"""
if tag in vtags:
return 1 - 1e-8
elif tag in itags:
return 1e-8
l = [
[
subset_vtags,
learned_landmark.model.p_can_see_tag(self, tag, subset_vtags,
itags)
] for subset_vtags in math2d.powerset(vtags)
#]
if len(subset_vtags) <= 3
]
l = na.array(l)
best = na.argmax(l[:, 1])
best_subset = l[best][0]
O_mat_entry = l[best][1]
if O_mat_entry < 0 or O_mat_entry > 1:
raise ValueError("Bad omat: " + ` O_mat_entry `)
return O_mat_entry
def main():
docs = list(
math2d.powerset([
"window", "door", "microwave", "refrigerator", "desk", "table",
"chair", "elevator", "clock", "urinal", "sink", "nice", "view"
]))
inference("data/flickrLda/input", docs)
def main():
from sys import argv
corpus_fname = argv[1]
model_fname = argv[2]
groundtruth_tag_fn = argv[3]
map_fname = argv[4]
evaluator = evaluate_model.Evaluator(corpus_fname,
model_fname,
groundtruth_tag_fn,
map_fname,
evaluation_mode="specialized")
evaluate_model.evaluator = evaluator
sr_classifier = evaluator.dg_model.sr_class
engineMap = sr_classifier.engineMap
out = []
#for subset in [set(engineMap.keys()) - set(["through"])]:
#for subset in [[x] for x in engineMap.keys()]:
for subset in math2d.powerset(engineMap.keys()):
if len(
subset
) > 3 or "turnRight" in subset or "turnLeft" in subset or "straight" in subset:
continue
subset_engine_map = dict([(key, None) for key in engineMap.keys()])
for key in subset:
subset_engine_map[key] = engineMap[key]
print "expect to call setter"
print 'cls', sr_classifier
print 'cls', sr_classifier.engineMap
sr_classifier.set_engine_map(subset_engine_map)
run_description = str(subset)
evaluator.run_description = run_description
print "starting", evaluator.run_description
correct_count, out_fname = evaluator.evaluateParallel()
out.append((run_description, correct_count, out_fname))
break
out.sort(key=lambda x: x[1], reverse=True)
for x in out:
print x
def p_can_see_tag(self, tag, vtags, itags):
"""
Find the subset of vtags that maximizes the p(x|subset_vtags)
and use that for the value.
"""
if any([x in vtags for x in [tag, tag[0:-1], tag[0:-2]]]):
return 1 - 1e-8
elif any([x in itags for x in [tag, tag[0:-1], tag[0:-2]]]):
return 1e-8
l = [[subset_vtags, naive_bayes.model.p_can_see_tag(self, tag, subset_vtags, itags)]
for subset_vtags in math2d.powerset(vtags)
if 1 <= len(subset_vtags) <= 3]
l = na.array(l)
if len(l) == 0:
return naive_bayes.model.p_can_see_tag(self, tag, [], itags)
else:
best = na.argmax(l[:, 1])
O_mat_entry = l[best][1]
assert 0 <= O_mat_entry <= 1, O_mat_entry
return O_mat_entry