def test_ordered_results_has_results_post_reset(self):
"""
Test that an empty list is returned after a reset where there was a
cached value before the reset.
"""
iqrs = IqrSession()
# Mocking results map existing for return.
d0 = DescriptorMemoryElement('', 0).set_vector([0])
d1 = DescriptorMemoryElement('', 1).set_vector([1])
d2 = DescriptorMemoryElement('', 2).set_vector([2])
d3 = DescriptorMemoryElement('', 3).set_vector([3])
iqrs.results = {
d0: 0.0,
d1: 0.8,
d2: 0.2,
d3: 0.4,
}
# Initial call to ``ordered_results`` should have a non-None return.
assert iqrs.ordered_results() is not None
iqrs.reset()
# Post-reset, there should be no results nor cache.
actual = iqrs.ordered_results()
assert actual == []
def test_get_unadjudicated_relevancy_no_cache_has_results(self):
"""
Test that we get the non-adjudicated DescriptorElements and their
scores correctly from a non-cached state with known results.
"""
iqrs = IqrSession()
d0 = DescriptorMemoryElement('', 0).set_vector([0])
d1 = DescriptorMemoryElement('', 1).set_vector([1])
d2 = DescriptorMemoryElement('', 2).set_vector([2])
d3 = DescriptorMemoryElement('', 3).set_vector([3])
# Simulate a populated contributing adjudication state (there must be
# some positives for a simulated post-refine state to be valid).
iqrs.rank_contrib_pos = {d1}
iqrs.rank_contrib_neg = {d0}
# Simulate post-refine results map.
iqrs.results = {
d0: 0.1,
d1: 0.8,
d2: 0.2,
d3: 0.4,
}
# Cache should be initially empty
assert iqrs._ordered_non_adj is None
# Test that the appropriate sorting actually occurs.
with mock.patch('smqtk.iqr.iqr_session.sorted',
side_effect=sorted) as m_sorted:
actual1 = iqrs.get_unadjudicated_relevancy()
m_sorted.assert_called_once()
expected = [(d3, 0.4), (d2, 0.2)]
assert actual1 == expected
# Calling the method a second time should not result in a ``sorted``
# operation due to caching.
with mock.patch('smqtk.iqr.iqr_session.sorted',
side_effect=sorted) as m_sorted:
actual2 = iqrs.get_unadjudicated_relevancy()
m_sorted.assert_not_called()
assert actual2 == expected
# Both returns should be shallow copies, thus not the same list
# instances.
assert id(actual1) != id(actual2)
def test_ordered_results_has_results_no_cache(self):
"""
Test that an appropriate list is returned by ``ordered_results`` after
a refinement has occurred.
"""
iqrs = IqrSession()
# Mocking results map existing for return.
d0 = DescriptorMemoryElement('', 0).set_vector([0])
d1 = DescriptorMemoryElement('', 1).set_vector([1])
d2 = DescriptorMemoryElement('', 2).set_vector([2])
d3 = DescriptorMemoryElement('', 3).set_vector([3])
iqrs.results = {
d0: 0.0,
d1: 0.8,
d2: 0.2,
d3: 0.4,
}
# Cache should be empty before call to ``ordered_results``
assert iqrs._ordered_results is None
with mock.patch('smqtk.iqr.iqr_session.sorted',
side_effect=sorted) as m_sorted:
actual1 = iqrs.ordered_results()
m_sorted.assert_called_once()
expected = [(d1, 0.8), (d3, 0.4), (d2, 0.2), (d0, 0.0)]
assert actual1 == expected
# Calling the method a second time should not result in a ``sorted``
# operation due to caching.
with mock.patch('smqtk.iqr.iqr_session.sorted') as m_sorted:
actual2 = iqrs.ordered_results()
m_sorted.assert_not_called()
assert actual2 == expected
# Both returns should be shallow copies, thus not the same list
# instances.
assert id(actual1) != id(actual2)
def test_refine_with_prev_results(self):
"""
Test that the results of RelevancyIndex ranking are directly reflected
in an existing results dictionary of probability values.
"""
# IqrSession instance. No config for rel_index because we will mock
# that.
iqrs = IqrSession()
# Mock relevancy index in order to check how its called and mock return
# value.
iqrs.rel_index = mock.MagicMock(spec=RelevancyIndex)
# Mock length to be non-zero to simulate it having contents
iqrs.rel_index.__len__.return_value = 1
test_in_pos_elem = DescriptorMemoryElement('t', 0).set_vector([0])
test_in_neg_elem = DescriptorMemoryElement('t', 1).set_vector([1])
test_ex_pos_elem = DescriptorMemoryElement('t', 2).set_vector([2])
test_ex_neg_elem = DescriptorMemoryElement('t', 3).set_vector([3])
test_other_elem = DescriptorMemoryElement('t', 4).set_vector([4])
# Mock return dictionary, probabilities don't matter much other than
# they are not 1.0 or 0.0.
iqrs.rel_index.rank.return_value = \
{e: 0.5 for e in [test_in_pos_elem, test_in_neg_elem,
test_other_elem]}
# Create a "previous state" of the results dictionary containing
# results from our "working set" of descriptor elements.
iqrs.results = {
test_in_pos_elem: 0.2,
test_in_neg_elem: 0.2,
test_other_elem: 0.2,
# ``refine`` replaces the previous dict, so disjoint keys are
# NOT retained.
'something else': 0.3,
}
# Prepare IQR state for refinement
# - set dummy internal/external positive negatives.
iqrs.external_descriptors(positive=[test_ex_pos_elem],
negative=[test_ex_neg_elem])
iqrs.adjudicate(new_positives=[test_in_pos_elem],
new_negatives=[test_in_neg_elem])
# Test calling refine method
iqrs.refine()
# We test that:
# - ``rel_index.rank`` called with the combination of
# external/adjudicated descriptor elements.
# - ``results`` attribute now has an dict value
# - value of ``results`` attribute is what we expect.
iqrs.rel_index.rank.assert_called_once_with(
{test_in_pos_elem, test_ex_pos_elem},
{test_in_neg_elem, test_ex_neg_elem},
)
assert iqrs.results is not None
assert len(iqrs.results) == 3
assert test_other_elem in iqrs.results
assert test_in_pos_elem in iqrs.results
assert test_in_neg_elem in iqrs.results
assert 'something else' not in iqrs.results
assert iqrs.results[test_other_elem] == 0.5
assert iqrs.results[test_in_pos_elem] == 0.5
assert iqrs.results[test_in_neg_elem] == 0.5