def test_positive_parent_multi(self): """fetching a parent term when terms have multiple parents.""" # load an ontology in which Y7 is connected to both Y2 and Y1 Yfile = join(testdir, "Ymulti.obo") Yobo = MinimalObo(Yfile) Ydefaults = dict.fromkeys(Yobo.ids(), 0.0001) Ydefaults["Y:003"] = 0.0002 Ydefaults["Y:005"] = 0.0002 # make slight variations of representations rs = ReferenceSet(dict(refA=0.5, refB=0.5), ids=Yobo.ids(), row_priors=Ydefaults) refA = Representation(name="refA") refA.set("Y:002", 0.5).set("Y:005", 1).impute(Yobo, Ydefaults) refB = Representation(name="refB") refB.set("Y:001", 0.5).impute(Yobo, Ydefaults) rs.add(refA).add(refB) rs.learn_obo(Yobo) self.assertEqual( rs._positive_ancestor(rs.columns["refA"], rs.rows["Y:007"]), rs.rows["Y:002"], "Y2 is a positive ancestor") self.assertEqual( rs._positive_ancestor(rs.columns["refB"], rs.rows["Y:007"]), rs.rows["Y:001"], "Y1 is a positive immediate parent")
def test_learn_from_obo(self): """create parents_of tuples for all features""" r1 = Representation(name="refA").set("DOID:0014667", 0.4) rs = ReferenceSet(dict(refA=0.5, refB=0.5), ids=obo.ids()) rs.add(r1) self.assertEqual(rs.parents, None) rs.learn_obo(obo) self.assertEqual(len(rs.parents), len(obo.ids()))
def test_between2(self): """inference when model equally similar to two refs""" # let ref universe have two annotations rs = ReferenceSet(dict(refA=0.5, refB=0.5), ids=self.obo.ids(), row_priors=self.obodefaults) rs.add(self.refA).add(self.refB) rs.learn_obo(self.obo) rs.prep() inf = rs.inference(self.y3model) self.assertAlmostEqual(inf["refA"], inf["refB"], msg="equally likely")
def test_between_refs_and_null(self): """inference when model is similar to two refs and a there is a null""" # let ref universe have two annotations and one null rs = ReferenceSet(dict(null=0.8, refA=0.15, refB=0.15), ids=self.obo.ids(), row_priors=self.obodefaults) rs.add(self.refA).add(self.refB) rs.learn_obo(self.obo) rs.prep() inf = rs.inference(self.y3model) self.assertAlmostEqual(inf["refA"], inf["refB"], msg="equally likely")
def test_model_nodata(self): """inference when references are unequal but model has no data""" model = Representation(name="nodata") # let ref universe have two annotations and one null rs = ReferenceSet(dict(null=0.8, refA=0.1, refB=0.1), ids=self.obo.ids(), row_priors=self.obodefaults) rs.add(self.refA).add(self.refB) rs.learn_obo(self.obo) rs.prep() inf = rs.inference(model) self.assertAlmostEqual(inf["refA"], inf["refB"], msg="equally likely")
def test_difference_in_priors(self): """inference when model matches two references, but have different priors""" # let ref universe have two annotations and one null rs = ReferenceSet(dict(null=0.85, refA=0.05, refB=0.1), ids=self.obo.ids(), row_priors=self.obodefaults) rs.add(self.refA).add(self.refB) rs.learn_obo(self.obo) rs.prep() inf = rs.inference(self.y3model) self.assertLess(inf["refA"], inf["refB"], msg="equal match, but A has weaker prior")
def test_FP_can_increase(self): """FP can in principle yield greater score""" # make a new reference set with different priors priors2 = self.priors.copy() priors2["Y:002"] = 0.1 rs2 = ReferenceSet(dict(null=0.4, refA=0.3, refB=0.3), ids=Yobo.ids(), row_priors=priors2) rs2.add(self.refnull).add(self.refA).add(self.refB) rs2.learn_obo(Yobo) FP = Representation(name="model").set("Y:002", 0.2) chain = rs2.inference_chain(FP, "refB", verbose=True, fp_penalty=1) chain.evaluate_inference() self.assertGreater(chain.posterior, chain.prior)
def test_positive_parent(self): """fetching a parent term that has a positive value.""" rs = ReferenceSet(dict(refA=0.5), ids=Yobo.ids(), row_priors=Ydefaults) refA = Representation(name="refA") refA.set("Y:002", 0.5).set("Y:005", 1).impute(Yobo, Ydefaults) rs.add(refA) rs.learn_obo(Yobo) refAindex = rs.columns["refA"] self.assertEqual(rs._positive_ancestor(refAindex, rs.rows["Y:002"]), rs.rows["Y:002"], "Y2 is itself is positive") self.assertEqual(rs._positive_ancestor(refAindex, rs.rows["Y:007"]), rs.rows["Y:002"], "Y2 is immediate parent of Y7") self.assertEqual(rs._positive_ancestor(refAindex, rs.rows["Y:006"]), rs.rows["Y:005"], "Y5 is immediate parent of Y6")
def test_underflow(self): """attempt to get underflow in individual p.""" # let model have very sure values model = Representation(name="underflow") model.set("Y:007", 0.00001).set("Y:004", 1).set("Y:003", 1) # let ref universe have two annotations and one null refA = Representation(name="refA").set("Y:003", 1) refB = Representation(name="refB").set("Y:003", 1) rs = ReferenceSet(dict(null=0.98, refA=0.001, refB=0.001), ids=self.obo.ids()) rs.add(refA).add(refB) rs.learn_obo(self.obo) rs.prep() result = rs.inference(model, verbose=True) self.assertGreaterEqual(result["refA"], 0, msg="must always be a number, even if zero") self.assertGreaterEqual(result["refB"], 0, msg="must always be a number, even if zero") self.assertGreaterEqual(result["refB"], 0, msg="must always be a number, even if zero")
def test_TP_scores_better_than_FP(self): """FPs must score lower than TPs""" # make a new reference set with different (lower) priors priors2 = self.priors.copy() priors2["Y:002"] = 0.55 priors2["Y:007"] = 0.15 rs2 = ReferenceSet(dict(null=0.4, refA=0.3, refB=0.3), ids=Yobo.ids(), row_priors=priors2) rs2.add(self.refnull).add(self.refA).add(self.refB) rs2.learn_obo(Yobo) # compare with refA, which has Y:002 equal to 1 FP = Representation(name="FP").set("Y:007", 1) chain_FP = rs2.inference_chain(FP, "refA", verbose=True, fp_penalty=2) chain_FP.evaluate_inference() TP = Representation(name="TP").set("Y:002", 1) chain_TP = rs2.inference_chain(TP, "refA", verbose=True) chain_TP.evaluate_inference() self.assertGreaterEqual(chain_TP.posterior, chain_FP.posterior)
def test_FP_with_fp_penalty(self): """FP increases more with lower fp_penalty""" # make a new reference set with different priors priors2 = self.priors.copy() priors2["Y:003"] = 0.4 priors2["Y:002"] = 0.15 priors2["Y:007"] = 0.1 rs2 = ReferenceSet(dict(null=0.4, ref=0.3), ids=Yobo.ids(), row_priors=priors2) ref = Representation(name="ref") ref.set("Y:001", 1).impute(Yobo, priors2) ref.set("Y:007", priors2["Y:007"] / 2) rs2.add(self.refnull).add(ref) rs2.learn_obo(Yobo) FP = Representation(name="model").set("Y:007", 0.35) chain1 = rs2.inference_chain(FP, "ref", verbose=True, fp_penalty=0.1) chain1.evaluate_inference() self.assertGreater(chain1.posterior, chain1.prior) chain2 = rs2.inference_chain(FP, "ref", verbose=True, fp_penalty=1) chain2.evaluate_inference() self.assertLess(chain2.posterior, chain1.posterior)
def test_inference_chain(self): """compute an inference chain.""" # create a reference set refA = Representation(name="refA") refA.set("Y:002", 1).impute(Yobo, Ydefaults) refB = Representation(name="refB") refB.set("Y:001", 1).impute(Yobo, Ydefaults) rs = ReferenceSet(dict(refA=0.5, refB=0.5), ids=Yobo.ids(), row_priors=Ydefaults) rs.add(refA).add(refB) rs.learn_obo(Yobo) # compute a chain object explaining scoring steps chain = rs.inference_chain(refA, "refB", verbose=True) self.assertEqual(chain.__dict__["model"], "refA") self.assertEqual(chain.__dict__["reference"], "refB") self.assertGreater(len(chain.data), 2, "data chain should describe multiple features") self.assertTrue("background" in chain.data[0].__dict__, "chain data have comparison information") self.assertTrue("result" in chain.data[0].__dict__, "chain data have TP/FP/etc codes")