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])