def test_experiment(self):
# This test performs two experiments with the environment in a row
_ = self.env.reset()
steps = 0
done = False
while not done:
steps += 1
_, reward, done, _ = self.env.step(self.treatment)
self.assertEqual(steps, self.n_steps)
# compare output with regular simulation
treat = prepare_dict(self.treatment, max_dosage=self.max_dosage)
for i, line in enumerate(self.cell_lines):
simulator = Simulator()
simulator.initialize(line)
r = simulator.apply_treatment(treat)
self.assertTrue(np.abs(r - reward[i]) < EPS)
_ = self.env.reset()
steps = 0
done = False
while not done:
steps += 1
_, reward, done, _ = self.env.step(self.treatment)
self.assertEqual(steps, self.n_steps)
# compare output with regular simulation
treat = prepare_dict(self.treatment, max_dosage=self.max_dosage)
for i, line in enumerate(self.cell_lines):
simulator = Simulator()
simulator.initialize(line)
r = simulator.apply_treatment(treat)
self.assertTrue(np.abs(r - reward[i]) < EPS)
def test_repeated_evaluation(self):
SEQUENTIAL_CONFIG = {
"n_steps": 3,
"cell_lines": ['DV90', 'HS695T'],
"objective": TestObjective(),
"max_dosage": 8000,
"domain": UnitSimplex(7),
"scale": "linear"
}
repeated_evaluator = Evaluator(SEQUENTIAL_CONFIG,
self.n_envs,
store=True,
repeated=True)
x = np.array([0.5, 0.5, 0, 0, 0, 0, 0])
treats = [
prepare_dict(x,
max_dosage=TEST_CONFIG["max_dosage"],
scale=TEST_CONFIG["scale"])
for _ in range(self.n_steps)
]
# use evaluator
_, prolifs = repeated_evaluator.evaluate([x]) # write test to check y
p = 1
for i in range(self.n_steps):
simulator = Simulator()
simulator.initialize("HS695T")
p *= simulator.apply_treatment(treats[i])
print("p: ", p)
print("prolis: ", prolifs)
self.assertAlmostEqual(prolifs[0][1], p)
repeated_evaluator.terminate()
def verify_sequential_search_result(cell_lines, n_steps, treatments, dosage, prolifs, obj_val, obj_type, lambd):
# check dosage value
ref_dosage = 0
for t in treatments:
for k in t:
ref_dosage += t[k]
assert np.abs(ref_dosage - dosage) < EPS, "Total concentration in record is off."
# check proliferation values
ref_prolifs = []
for i, line in enumerate(cell_lines):
simulator = Simulator()
simulator.initialize(line)
for j in range(n_steps):
p = simulator.apply_treatment(treatments[j])
ref_prolifs.append(p)
assert np.abs(ref_prolifs[i] - prolifs[i]) < EPS, "Proliferation value in record is off."
# check objective value
if obj_type == "avg":
ref_obj = np.average(ref_prolifs) + lambd * ref_dosage
elif obj_type == "worst":
ref_obj = np.max(ref_prolifs) + lambd * ref_dosage
else:
raise ValueError("Given objective is unknown.")
assert np.abs(ref_obj - obj_val) < EPS, "Objective value in record is off."
def test_sequential_evaluation(self):
seq_simplex = SequentialSimplex(self.dim, self.n_steps)
x = seq_simplex.uniform()
treats = [prepare_dict(x[i * self.dim:(i + 1) * self.dim], max_dosage=TEST_CONFIG["max_dosage"], scale=TEST_CONFIG["scale"]) for i in range(self.n_steps)]
# use evaluator
ys, prolifs = self.evaluator.evaluate([x])
# compare with SKMEL24 evaluation of single steps
p = 1
for i in range(self.n_steps):
simulator = Simulator()
simulator.initialize("SKMEL24")
p *= simulator.apply_treatment(treats[i])
self.assertAlmostEqual(prolifs[0][1], p)
def test_evaluate(self):
ys, prolifs = self.evaluator.evaluate(self.xs)
ys, prolifs = self.evaluator.evaluate(self.xs)
# compare results with direct serial execution
for i, x in enumerate(self.xs):
self.assertTrue(np.abs(ys[i] - np.average(prolifs[i])) < EPS)
avg = 0
for j, line in enumerate(TEST_CONFIG["cell_lines"]):
treat = prepare_dict(x, max_dosage=TEST_CONFIG["max_dosage"])
simulator = Simulator()
simulator.initialize(line)
r = simulator.apply_treatment(treat)
self.assertTrue(np.abs(prolifs[i][j] - r) < EPS)
avg += r
avg /= len(TEST_CONFIG["cell_lines"])
self.assertTrue(np.abs(avg - ys[i]) < EPS)
def test_buffer(self):
# test if things get stored in buffer correctly
_, _ = self.evaluator.evaluate(self.xs)
buffer_dict = self.evaluator.get_res_dict()
self.assertEqual(
len(buffer_dict[TEST_CONFIG["cell_lines"][0]]
["relative_proliferation"]), EVALS)
# compare buffer content with direct serial execution
for i, x in enumerate(self.xs):
for line in TEST_CONFIG["cell_lines"]:
treat = prepare_dict(x, max_dosage=TEST_CONFIG["max_dosage"])
simulator = Simulator()
simulator.initialize(line)
prolif = simulator.apply_treatment(treat)
self.assertTrue(
np.abs(prolif -
buffer_dict[line]["relative_proliferation"][i]) <=
EPS)
def test_cma_es(self):
mu, obj, prolif = cma_es(self.evaluator,
self.domain,
MAX_ITER,
verbose=True,
seed=23)
self.assertTrue(np.abs(obj - np.average(prolif)) < EPS)
self.assertTrue(self.domain.contains(mu))
# compare objective with sequential computation
treatment = prepare_dict(mu.flatten(),
max_dosage=TEST_CONFIG["max_dosage"],
scale=TEST_CONFIG["scale"])
print(treatment)
prolifs = []
for line in TEST_CONFIG["cell_lines"]:
simulator = Simulator()
simulator.initialize(line)
prolifs.append(simulator.apply_treatment(treatment))
o = TEST_CONFIG["objective"].eval(prolifs, treatment)
self.assertTrue(np.abs(obj - o) <= EPS)
def test_sequential_cma_es(self):
mu, obj, prolif = cma_es(self.evaluator, self.domain, MAX_ITER, verbose=True, seed=23)
# generate total dosage
total_dosage = sum([8000 * x for x in mu])
self.assertTrue(np.abs(obj - (np.max(prolif) + LAMBD * total_dosage)) < EPS)
self.assertTrue(self.domain.contains(mu))
# compare objective with sequential computation
mu = mu.flatten()
treats = [prepare_dict(mu[i * self.dim:(i + 1) * self.dim], max_dosage=TEST_CONFIG["max_dosage"], scale=TEST_CONFIG["scale"]) for i in range(self.n_steps)]
cum_treat = empty_treatment()
prolifs = []
for line in TEST_CONFIG["cell_lines"]:
simulator = Simulator()
simulator.initialize(line)
for t in treats:
p = simulator.apply_treatment(t)
prolifs.append(p)
for t in treats:
for k in t:
cum_treat[k] += t[k]
o = TEST_CONFIG["objective"].eval(prolifs, cum_treat)
self.assertTrue(np.abs(obj - o) <= EPS)
def experiment_batch(arg):
simulator = Simulator()
res = []
for con in arg["concentations"]:
treatment = empty_treatment()
treatment[arg["drug"]] = con
simulator.initialize(arg["cell_line"])
rel_proliferation = simulator.apply_treatment(treatment)
simulator.initialized = False
res.append(rel_proliferation)
return res
def dual_drug_batch(arg):
simulator = Simulator()
res = []
for con in arg["concentations"]:
treatment = empty_treatment()
treatment['PD0325901'] = (1 - (arg["ratio"] / 100.0)) * con
treatment['PLX-4720'] = (arg["ratio"] / 100.0) * con
simulator.initialize(arg["cell_line"])
rel_proliferation = simulator.apply_treatment(treatment)
simulator.initialized = False
res.append(rel_proliferation)
return res
def test_sequential_single_drug(self):
# get single step result
single_step_treatment = np.zeros(self.dim)
single_step_treatment[0] = 1
single_treat = prepare_dict(single_step_treatment, max_dosage=8000)
simulator = Simulator()
simulator.initialize("SKMEL24")
sp1 = simulator.apply_treatment(single_treat)
sp2 = simulator.apply_treatment(single_treat)
sp3 = simulator.apply_treatment(single_treat)
self.assertAlmostEqual(sp2, sp1 * sp1)
self.assertAlmostEqual(sp3, sp1 ** 3)
self.assertAlmostEqual(sp3, sp1 * sp2)
# get multi-step result
multi_step_treatment = np.zeros(self.dim * self.n_steps)
for i in range(self.n_steps):
multi_step_treatment[i * self.dim] = 1
ys, prolifs = self.evaluator.evaluate([multi_step_treatment])
self.assertAlmostEqual(sp1 ** 3, prolifs[0][1])
self.assertAlmostEqual(sp1 ** 3 + LAMBD * 3 * 8000, ys[0])