def test_stack_same_config(self):
"""Test stack method with same configuration."""
n_stimuli = 10
model_truth = ground_truth(n_stimuli)
n_trial = 50
n_reference = 8
n_select = 2
generator = RandomRank(
n_stimuli, n_reference=n_reference, n_select=n_select
)
docket = generator.generate(n_trial)
double_trials = trials.stack((docket, docket))
assert double_trials.n_trial == 2 * n_trial
np.testing.assert_array_equal(
double_trials.n_reference[0:n_trial], docket.n_reference)
np.testing.assert_array_equal(
double_trials.n_reference[n_trial:], docket.n_reference)
np.testing.assert_array_equal(
double_trials.n_select[0:n_trial], docket.n_select)
np.testing.assert_array_equal(
double_trials.n_select[n_trial:], docket.n_select)
np.testing.assert_array_equal(
double_trials.is_ranked[0:n_trial], docket.is_ranked)
np.testing.assert_array_equal(
double_trials.is_ranked[n_trial:], docket.is_ranked)
agent_novice = RankAgent(model_truth, group_id=0)
agent_expert = RankAgent(model_truth, group_id=1)
obs_novice = agent_novice.simulate(docket)
obs_expert = agent_expert.simulate(docket)
obs_all = trials.stack((obs_novice, obs_expert))
assert obs_all.n_trial == 2 * n_trial
np.testing.assert_array_equal(
obs_all.n_reference[0:n_trial], obs_novice.n_reference)
np.testing.assert_array_equal(
obs_all.n_reference[n_trial:], obs_expert.n_reference)
np.testing.assert_array_equal(
obs_all.n_select[0:n_trial], obs_novice.n_select)
np.testing.assert_array_equal(
obs_all.n_select[n_trial:], obs_expert.n_select)
np.testing.assert_array_equal(
obs_all.is_ranked[0:n_trial], obs_novice.is_ranked)
np.testing.assert_array_equal(
obs_all.is_ranked[n_trial:], obs_expert.is_ranked)
np.testing.assert_array_equal(
obs_all.group_id[0:n_trial], obs_novice.group_id)
np.testing.assert_array_equal(
obs_all.group_id[n_trial:], obs_expert.group_id)
def test_stack_config_idx(self):
"""Test if config_idx is updated correctly after stack."""
stimulus_set = np.array((
(0, 1, 2, 3, -1, -1, -1, -1, -1),
(9, 12, 7, 1, -1, -1, -1, -1, -1),
(3, 4, 5, 6, 7, -1, -1, -1, -1),
(3, 4, 2, 6, 7, -1, -1, -1, -1),
(3, 4, 5, 6, 13, 14, 15, 16, 17)))
# Create first set of original trials.
n_select = np.array((1, 1, 1, 1, 1))
trials_0 = trials.RankObservations(stimulus_set, n_select=n_select)
desired_config_idx = np.array((0, 0, 1, 1, 2))
np.testing.assert_array_equal(trials_0.config_idx, desired_config_idx)
# Create second set of original trials, with non-overlapping
# configuration.
n_select = np.array((2, 2, 2, 2, 2))
trials_1 = trials.RankObservations(stimulus_set, n_select=n_select)
desired_config_idx = np.array((0, 0, 1, 1, 2))
np.testing.assert_array_equal(trials_1.config_idx, desired_config_idx)
# Stack trials
trials_stack = trials.stack((trials_0, trials_1))
desired_config_idx = np.array((0, 0, 1, 1, 2, 3, 3, 4, 4, 5))
np.testing.assert_array_equal(
trials_stack.config_idx, desired_config_idx)
def test_padding(self):
"""Test padding values when using stack and subset method."""
n_stimuli = 20
n_trial = 5
n_reference1 = 2
n_select1 = 1
generator = RandomRank(
n_stimuli, n_reference=n_reference1, n_select=n_select1
)
trials1 = generator.generate(n_trial)
n_reference2 = 4
n_select2 = 2
generator = RandomRank(
n_stimuli, n_reference=n_reference2, n_select=n_select2
)
trials2 = generator.generate(n_trial)
n_reference3 = 8
n_select3 = 2
generator = RandomRank(
n_stimuli, n_reference=n_reference3, n_select=n_select3
)
trials3 = generator.generate(n_trial)
trials_all = trials.stack((trials1, trials2, trials3))
# Check padding values of first set (non-padded and then padded
# values).
assert np.sum(np.equal(trials_all.stimulus_set[1:5, 0:3], -1)) == 0
np.testing.assert_array_equal(
trials_all.stimulus_set[0:5, 3:],
-1 * np.ones((5, 6), dtype=np.int32)
)
# Check padding values of second set (non-padded and then padded
# values).
assert np.sum(np.equal(trials_all.stimulus_set[5:10, 0:5], -1)) == 0
np.testing.assert_array_equal(
trials_all.stimulus_set[5:10, 5:],
-1 * np.ones((5, 4), dtype=np.int32)
)
# Check padding values of third set (non-padded and then padded
# values).
assert np.sum(np.equal(trials_all.stimulus_set[10:15, :], -1)) == 0
# Check padding when taking subset.
trials_subset = trials_all.subset(np.arange(10))
assert trials_subset.stimulus_set.shape[1] == 5
# Check padding values of first set (non-padded and then padded
# values).
assert np.sum(np.equal(trials_subset.stimulus_set[1:5, 0:3], -1)) == 0
np.testing.assert_array_equal(
trials_subset.stimulus_set[0:5, 3:],
-1 * np.ones((5, 2), dtype=np.int32)
)
# Check padding values of second set (non-padded and then padded
# values).
assert np.sum(np.equal(trials_subset.stimulus_set[5:10, 0:5], -1)) == 0
def _select_references(
self, model_list, group_id, query_idx_arr, query_idx_count_arr,
q_priority, r_priority, verbose):
"""Determine references for all requested query stimuli."""
n_query = query_idx_arr.shape[0]
if verbose > 0:
progbar = ProgressBarRe(
n_query, prefix='Active Trials:', length=50
)
progbar.update(0)
docket = None
expected_ig = None
for i_query in range(n_query):
r_priority_q = r_priority[query_idx_arr[i_query]]
docket_q, expected_ig_q = _select_query_references(
i_query, model_list, group_id, query_idx_arr,
query_idx_count_arr,
self.n_reference, self.n_select, self.n_candidate,
r_priority_q, self.batch_size
)
if verbose > 0:
progbar.update(i_query + 1)
# Add to dynamic list.
if expected_ig is None:
expected_ig = expected_ig_q
else:
expected_ig = np.hstack((expected_ig, expected_ig_q))
if docket is None:
docket = docket_q
else:
docket = stack((docket, docket_q))
return docket, expected_ig
def test_stack_different_config(self):
"""Test stack static method with different configurations."""
n_stimuli = 20
n_trial = 5
n_reference1 = 2
n_select1 = 1
generator = RandomRank(
n_stimuli, n_reference=n_reference1, n_select=n_select1
)
trials1 = generator.generate(n_trial)
n_reference2 = 4
n_select2 = 2
generator = RandomRank(
n_stimuli, n_reference=n_reference2, n_select=n_select2
)
trials2 = generator.generate(n_trial)
n_reference3 = 6
n_select3 = 2
generator = RandomRank(
n_stimuli, n_reference=n_reference3, n_select=n_select3
)
trials3 = generator.generate(n_trial)
trials_all = trials.stack((trials1, trials2, trials3))
desired_n_reference = np.hstack((
n_reference1 * np.ones((n_trial), dtype=np.int32),
n_reference2 * np.ones((n_trial), dtype=np.int32),
n_reference3 * np.ones((n_trial), dtype=np.int32),
))
np.testing.assert_array_equal(
trials_all.n_reference, desired_n_reference
)