def test_adjudicate_unadj_noeffect(self):
"""
Test that an empty call, or un-adjudicating a descriptor that is not
currently marked as a positive or negative, causes no state change.
"""
iqrs = IqrSession()
# Set initial state
p0 = DescriptorMemoryElement('', 0).set_vector([0])
p1 = DescriptorMemoryElement('', 1).set_vector([1])
p2 = DescriptorMemoryElement('', 2).set_vector([2])
n3 = DescriptorMemoryElement('', 3).set_vector([3])
n4 = DescriptorMemoryElement('', 4).set_vector([4])
# Set initial state
iqrs.positive_descriptors = {p0, p1, p2}
iqrs.negative_descriptors = {n3, n4}
# Empty adjudication
iqrs.adjudicate()
assert iqrs.positive_descriptors == {p0, p1, p2}
assert iqrs.negative_descriptors == {n3, n4}
# Attempt un-adjudication of a non-adjudicated element.
e = DescriptorMemoryElement('', 5).set_vector([5])
iqrs.adjudicate(un_positives=[e], un_negatives=[e])
assert iqrs.positive_descriptors == {p0, p1, p2}
assert iqrs.negative_descriptors == {n3, n4}
def test_adjudication_switch(self):
"""
Test providing positives and negatives on top of an existing state such
that the descriptor adjudications are reversed. (what was once positive
is now negative, etc.)
"""
iqrs = IqrSession()
p0 = DescriptorMemoryElement('', 0).set_vector([0])
p1 = DescriptorMemoryElement('', 1).set_vector([1])
p2 = DescriptorMemoryElement('', 2).set_vector([2])
n3 = DescriptorMemoryElement('', 3).set_vector([3])
n4 = DescriptorMemoryElement('', 4).set_vector([4])
# Set initial state
iqrs.positive_descriptors = {p0, p1, p2}
iqrs.negative_descriptors = {n3, n4}
# Adjudicate, partially swapping adjudications individually
iqrs.adjudicate(new_positives=[n3])
assert iqrs.positive_descriptors == {p0, p1, p2, n3}
assert iqrs.negative_descriptors == {n4}
iqrs.adjudicate(new_negatives=[p1])
assert iqrs.positive_descriptors == {p0, p2, n3}
assert iqrs.negative_descriptors == {n4, p1}
# Adjudicate swapping remaining at the same time
iqrs.adjudicate(new_positives=[n4], new_negatives=[p0, p2])
assert iqrs.positive_descriptors == {n3, n4}
assert iqrs.negative_descriptors == {p0, p1, p2}
def test_adjudicate_combined_remove_unadj(self):
"""
Test combining adjudication switching with un-adjudication.
"""
iqrs = IqrSession()
# Set initial state
p0 = DescriptorMemoryElement('', 0).set_vector([0])
p1 = DescriptorMemoryElement('', 1).set_vector([1])
p2 = DescriptorMemoryElement('', 2).set_vector([2])
n3 = DescriptorMemoryElement('', 3).set_vector([3])
n4 = DescriptorMemoryElement('', 4).set_vector([4])
# Set initial state
iqrs.positive_descriptors = {p0, p1, p2}
iqrs.negative_descriptors = {n3, n4}
# Add p5, switch p1 to negative, unadj p2
p5 = DescriptorMemoryElement('', 5).set_vector([5])
iqrs.adjudicate(new_positives=[p5],
new_negatives=[p1],
un_positives=[p2])
assert iqrs.positive_descriptors == {p0, p5}
assert iqrs.negative_descriptors == {n3, n4, p1}
# Add n6, switch n4 to positive, unadj n3
n6 = DescriptorMemoryElement('', 6).set_vector([6])
iqrs.adjudicate(new_positives=[n4],
new_negatives=[n6],
un_negatives=[n3])
assert iqrs.positive_descriptors == {p0, p5, n4}
assert iqrs.negative_descriptors == {p1, n6}
def test_adjudicate_remove_pos_neg(self):
"""
Test that we can remove positive and negative adjudications using
"un_*" parameters.
"""
iqrs = IqrSession()
# Set initial state
p0 = DescriptorMemoryElement('', 0).set_vector([0])
p1 = DescriptorMemoryElement('', 1).set_vector([1])
p2 = DescriptorMemoryElement('', 2).set_vector([2])
n3 = DescriptorMemoryElement('', 3).set_vector([3])
n4 = DescriptorMemoryElement('', 4).set_vector([4])
# Set initial state
iqrs.positive_descriptors = {p0, p1, p2}
iqrs.negative_descriptors = {n3, n4}
# "Un-Adjudicate" descriptors individually
iqrs.adjudicate(un_positives=[p1])
assert iqrs.positive_descriptors == {p0, p2}
assert iqrs.negative_descriptors == {n3, n4}
iqrs.adjudicate(un_negatives=[n3])
assert iqrs.positive_descriptors == {p0, p2}
assert iqrs.negative_descriptors == {n4}
# "Un-Adjudicate" collectively
iqrs.adjudicate(un_positives=[p0, p2], un_negatives=[n4])
assert iqrs.positive_descriptors == set()
assert iqrs.negative_descriptors == set()
def test_get_session_info(self):
"""
Test a valid retrieval of a complex IQR session state.
"""
rank_relevancy_with_feedback = mock.MagicMock(
spec=RankRelevancyWithFeedback)
iqrs = IqrSession(rank_relevancy_with_feedback, session_uid='abc')
ep, en, p1, p2, p3, n1, n2, d1, d2, n3 = [
DescriptorMemoryElement('test', uid)
for uid in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
# ep en p1 p2 p3 n1 n2 d1 d2 n3
] # C C C C C C
# ^Contributing^
# Current adjudications
iqrs.external_positive_descriptors = {ep}
iqrs.positive_descriptors = {p1, p2, p3}
iqrs.external_negative_descriptors = {en}
iqrs.negative_descriptors = {n1, n2, n3}
# "Last Refine" adjudications
# - simulating that "currently" neutral descriptors were previous
# adjudicated.
iqrs.rank_contrib_pos = {p2, d1}
iqrs.rank_contrib_pos_ext = {ep}
iqrs.rank_contrib_neg = {n1, n3, d2}
iqrs.rank_contrib_neg_ext = set()
# mock working set with
iqrs.working_set.add_many_descriptors([p1, p2, p3, n1, n2, d1, d2, n3])
self.app.controller.add_session(iqrs)
with self.app.test_client() as tc:
#: :type: flask.wrappers.Response
r = tc.get('/session?sid=abc')
self.assertStatusCode(r, 200)
r_json = r.json
assert r_json['sid'] == 'abc'
# That everything included in "current" adjudications is included
# here.
assert set(r_json['uuids_pos_ext']) == {'a'}
assert set(r_json['uuids_pos']) == {'c', 'd', 'e'}
assert set(r_json['uuids_neg_ext']) == {'b'}
assert set(r_json['uuids_neg']) == {'f', 'g', 'j'}
# That those marked as "contributing" are included here
assert set(r_json['uuids_pos_in_model']) == {'d', 'h'}
assert set(r_json['uuids_pos_ext_in_model']) == {'a'}
assert set(r_json['uuids_neg_in_model']) == {'f', 'j', 'i'}
assert set(r_json['uuids_neg_ext_in_model']) == set()
# IQR working set expected size
assert r_json['wi_count'] == 8
def test_adjudication_cache_not_reset(self):
"""
Test that pos/neg/non-adj result caches are NOT reset when no state
change occurs under different circumstances
"""
# setup initial IQR session state.
p0 = DescriptorMemoryElement('', 0).set_vector([0])
p1 = DescriptorMemoryElement('', 1).set_vector([1])
p2 = DescriptorMemoryElement('', 2).set_vector([2])
n3 = DescriptorMemoryElement('', 3).set_vector([3])
n4 = DescriptorMemoryElement('', 4).set_vector([4])
iqrs = IqrSession()
iqrs.positive_descriptors = {p0, p1, p2}
iqrs.negative_descriptors = {n3, n4}
iqrs._ordered_pos = iqrs._ordered_neg = iqrs._ordered_non_adj = True
# Empty adjudication
iqrs.adjudicate()
assert iqrs._ordered_pos is True
assert iqrs._ordered_neg is True
assert iqrs._ordered_non_adj is True
# Repeat positive/negative adjudication
iqrs.adjudicate(new_positives=[p0])
assert iqrs._ordered_pos is True
assert iqrs._ordered_neg is True
assert iqrs._ordered_non_adj is True
iqrs.adjudicate(new_negatives=[n3])
assert iqrs._ordered_pos is True
assert iqrs._ordered_neg is True
assert iqrs._ordered_non_adj is True
iqrs.adjudicate(new_positives=[p1], new_negatives=[n4])
assert iqrs._ordered_pos is True
assert iqrs._ordered_neg is True
assert iqrs._ordered_non_adj is True
# No-op un-adjudication
e = DescriptorMemoryElement('', 5).set_vector([5])
iqrs.adjudicate(un_positives=[e], un_negatives=[e])
assert iqrs._ordered_pos is True
assert iqrs._ordered_neg is True
assert iqrs._ordered_non_adj is True
def test_adjudicate_both_labels(self):
"""
Test that providing a descriptor element as both a positive AND
negative adjudication causes no state change..
"""
iqrs = IqrSession()
# Set initial state
p0 = DescriptorMemoryElement('', 0).set_vector([0])
p1 = DescriptorMemoryElement('', 1).set_vector([1])
p2 = DescriptorMemoryElement('', 2).set_vector([2])
n3 = DescriptorMemoryElement('', 3).set_vector([3])
n4 = DescriptorMemoryElement('', 4).set_vector([4])
# Set initial state
iqrs.positive_descriptors = {p0, p1, p2}
iqrs.negative_descriptors = {n3, n4}
# Attempt adjudicating a new element as both postive AND negative
e = DescriptorMemoryElement('', 5).set_vector([5])
iqrs.adjudicate(new_positives=[e], new_negatives=[e])
assert iqrs.positive_descriptors == {p0, p1, p2}
assert iqrs.negative_descriptors == {n3, n4}
