Debian Codegraph @

csb/test/cases/bio/hmm/__init__.py

raw
1 import csb.test as test
2
3 from csb.core import Enum, OrderedDict
4
5 from csb.bio.hmm import State, Transition, ProfileHMM, HMMLayer, ProfileLength, StateFactory, ProfileHMMSegment
6 from csb.bio.hmm import StateExistsError, UnobservableStateError, EmissionExistsError
7 from csb.bio.hmm import HHpredHitList, HHpredHit, ScoreUnits, States, EVDParameters, BACKGROUND
8 from csb.bio.sequence import ProteinAlphabet
9 from csb.bio.structure import ProteinResidue
10
11 from csb.bio.io import HHProfileParser
12
13
14
15 def build_hmm():
16
17 hmm = ProfileHMM(units=ScoreUnits.Probability)
18
19 factory = StateFactory()
20 background = OrderedDict([ (ProteinAlphabet.ALA, 0.02457563),
21 (ProteinAlphabet.CYS, 0.00325358),
22 (ProteinAlphabet.GLU, 0.01718016) ])
23
24 emission = dict( (aa, 1.0 / i) for i, aa in enumerate(background, start=1) )
25
26 # States
27 # Start / End
28 hmm.start = State(States.Start)
29 hmm.start_insertion = factory.create_insertion(background)
30 hmm.end = State(States.End)
31 # L1
32 match1 = factory.create_match(emission, background)
33 insertion1 = factory.create_insertion(background)
34 deletion1 = factory.create_deletion()
35 states = {States.Match: match1, States.Insertion: insertion1, States.Deletion: deletion1}
36 layer1 = HMMLayer(1, ProteinResidue(1, ProteinAlphabet.ALA), states)
37 hmm.layers.append(layer1)
38 # L2
39 match2 = factory.create_match(emission, background)
40 insertion2 = factory.create_insertion(background)
41 deletion2 = factory.create_deletion()
42 states = {States.Match: match2, States.Insertion: insertion2, States.Deletion: deletion2}
43 layer2 = HMMLayer(2, ProteinResidue(2, ProteinAlphabet.CYS), states)
44 hmm.layers.append(layer2)
45
46 # Transitions
47 # start
48 hmm.start.transitions.append(Transition(hmm.start, match1, 0.8))
49 hmm.start.transitions.append(Transition(hmm.start, deletion1, 0.1))
50 hmm.start.transitions.append(Transition(hmm.start, hmm.start_insertion, 0.1))
51 hmm.start_insertion.transitions.append(Transition(hmm.start_insertion, hmm.start_insertion, 0.5))
52 hmm.start_insertion.transitions.append(Transition(hmm.start_insertion, match1, 0.5))
53 # L1
54 match1.transitions.append(Transition(match1, match2, 0.8))
55 match1.transitions.append(Transition(match1, insertion1, 0.1))
56 match1.transitions.append(Transition(match1, deletion2, 0.1))
57 insertion1.transitions.append(Transition(insertion1, insertion1, 0.5))
58 insertion1.transitions.append(Transition(insertion1, match2, 0.5))
59 deletion1.transitions.append(Transition(deletion1, deletion2, 0.5))
60 deletion1.transitions.append(Transition(deletion1, match2, 0.5))
61 # L2
62 match2.transitions.append(Transition(match2, hmm.end, 0.9))
63 match2.transitions.append(Transition(match2, insertion2, 0.1))
64 insertion2.transitions.append(Transition(insertion2, insertion2, 0.5))
65 insertion2.transitions.append(Transition(insertion2, hmm.end, 0.5))
66 deletion2.transitions.append(Transition(deletion2, hmm.end, 1.0))
67
68 hmm.effective_matches = 10
69 hmm.version = 1.5
70 hmm.name = 'name'
71 hmm.id = 'id'
72 hmm.family = 'fam'
73 hmm.length = ProfileLength(2, 2)
74
75 return hmm
76
77
78 @test.unit
79 class TestProfileHMM(test.Case):
80
81 def setUp(self):
82
83 super(TestProfileHMM, self).setUp()
84
85 self.hmm = build_hmm()
86 self.hmm2 = build_hmm()
87 self.string = self.config.getContent('test.hhm')
88
89 def testName(self):
90 self.assertEqual(self.hmm.name, 'name')
91
92 def testID(self):
93 self.assertEqual(self.hmm.id, 'id')
94
95 def testLayers(self):
96
97 self.assertEqual(self.hmm.layers.length, 2)
98 self.assertTrue(isinstance(self.hmm.layers[1], HMMLayer))
99 self.assertEqual(set(self.hmm.layers[1]), set([States.Match, States.Insertion, States.Deletion]))
100
101 for i in [0, 3]:
102 self.assertRaises(IndexError, lambda:self.hmm.layers[i])
103
104 def testStart(self):
105 self.assertEqual(self.hmm.start.type, States.Start)
106
107 def testStartInsertion(self):
108 self.assertEqual(self.hmm.start_insertion.type, States.Insertion)
109
110 def testEnd(self):
111 self.assertEqual(self.hmm.end.type, States.End)
112
113 def testAllLayers(self):
114 self.assertEqual(len(self.hmm.all_layers), 3)
115
116 def testScoreUnits(self):
117 self.assertEqual(self.hmm.score_units, ScoreUnits.Probability)
118
119 self.hmm2.convert_scores(units=ScoreUnits.LogScales)
120 self.assertEqual(self.hmm2.score_units, ScoreUnits.LogScales)
121
122 def testConvertScores(self):
123
124 self.hmm2.convert_scores(units=ScoreUnits.LogScales)
125 self.assertEqual(self.hmm2.score_units, ScoreUnits.LogScales)
126 self.assertEqual(self.hmm2.layers[1][States.Match].emission[ProteinAlphabet.ALA], 0)
127
128 self.hmm2.convert_scores(units=ScoreUnits.Probability)
129 self.assertEqual(self.hmm2.score_units, ScoreUnits.Probability)
130 self.assertEqual(self.hmm2.layers[1][States.Match].emission[ProteinAlphabet.ALA], 1)
131
132 def testSegment(self):
133
134 segment = self.hmm.segment(1, 2)
135 self.assertEqual(segment.layers.length, 2)
136 self.assertEqual(segment.layers[2][States.Match].transitions[States.End].probability, 1)
137 self.assertRaises(IndexError, self.hmm.segment, 1, 3)
138
139 def testSubregion(self):
140
141 segment = self.hmm.subregion(1, 2)
142 self.assertEqual(segment.layers.length, 2)
143 self.assertEqual(segment.layers[1], self.hmm.layers[1])
144 self.assertRaises(IndexError, self.hmm.subregion, 1, 3)
145
146 def testStructure(self):
147 s = self.hmm.structure('$', 'abcd')
148
149 self.assertEqual(s.chains.length, 1)
150 self.assertEqual(s.chains['$'].entry_id, 'abcd$')
151 self.assertEqual(s.chains['$'].sequence, 'AC')
152
153 def testChain(self):
154 c = self.hmm.chain('$')
155
156 self.assertEqual(c.id, '$')
157 self.assertEqual(c.sequence, 'AC')
158
159 def testEmissionSimilarity(self):
160
161 score = self.hmm.emission_similarity(self.hmm)
162 self.assertAlmostEqual(score, 9.6405, places=3)
163
164 def testToHMM(self):
165
166 self.hmm2.convert_scores(units=ScoreUnits.LogScales)
167 self.assertEqual(self.string, self.hmm2.to_hmm().strip())
168
169 @test.functional
170 class TestPseudocountBuilder(test.Case):
171
172 def setUp(self):
173
174 super(TestPseudocountBuilder, self).setUp()
175 self.hmm = HHProfileParser(self.config.getTestFile('d1nz0a_.hhm')).parse()
176
177 def runTest(self):
178 self.hmm.add_emission_pseudocounts()
179 self.hmm.convert_scores(ScoreUnits.LogScales)
180 self.hmm.add_transition_pseudocounts()
181 # TODO: some checks here...
182
183 @test.unit
184 class TestProfileHMMSegment(test.Case):
185
186 def setUp(self):
187
188 super(TestProfileHMMSegment, self).setUp()
189
190 self.hmm = build_hmm()
191 self.segment = ProfileHMMSegment(self.hmm, 1, 2)
192 self.string = self.config.getContent('test2.hhm')
193
194 def testConstructor(self):
195
196 self.segment.convert_scores(ScoreUnits.Probability)
197
198 self.assertEqual(self.hmm.segment(1, 1).layers.length, 1)
199 self.assertEqual(self.segment.layers.length, 2)
200 self.assertEqual(self.segment.start.transitions[States.Match].probability, 1)
201 self.assertEqual(self.segment.layers[1][States.Match].emission[ProteinAlphabet.CYS], 0.5)
202 self.assertRaises(IndexError, self.hmm.segment, 1, 3)
203
204 self.hmm.convert_scores(ScoreUnits.LogScales)
205 segment = ProfileHMMSegment(self.hmm, 1, 2)
206 self.assertEqual(segment.source_start, 1)
207
208 def testToHMM(self):
209
210 self.segment.convert_scores(ScoreUnits.LogScales)
211 self.assertEqual(self.string, self.segment.to_hmm().strip())
212
213
214 @test.unit
215 class TestHMMLayer(test.Case):
216
217 def setUp(self):
218
219 super(TestHMMLayer, self).setUp()
220 self.hmm = build_hmm()
221 self.layer = self.hmm.layers[1]
222
223 self.layer.effective_matches = 5
224 self.layer.effective_insertions = 4
225 self.layer.effective_deletions = 3
226
227 def testRank(self):
228 self.assertEqual(self.hmm.layers[1].rank, 1)
229 self.assertEqual(self.hmm.layers[2].rank, 2)
230
231 def testNeff(self):
232 self.assertEqual(self.layer.effective_matches, 5)
233 self.assertEqual(self.layer.effective_insertions, 4)
234 self.assertEqual(self.layer.effective_deletions, 3)
235
236 def testResidue(self):
237 def test(type):
238 self.layer.residue = ProteinResidue(1, type=type)
239
240 self.assertEqual(self.layer.residue.type, ProteinAlphabet.ALA)
241 self.assertRaises(ValueError, test, ProteinAlphabet.GAP)
242 test(ProteinAlphabet.ALA)
243 self.assertEqual(self.layer.residue.type, ProteinAlphabet.ALA)
244
245 def testAppend(self):
246
247 s = State(States.End)
248 self.layer.append(s)
249
250 self.assertRaises(StateExistsError, self.layer.append, s)
251 self.assertEqual(self.layer[States.End], s)
252
253 def testIndexer(self):
254 self.assertEqual(self.layer[States.Match].type, States.Match)
255
256
257 @test.unit
258 class TestState(test.Case):
259
260 def setUp(self):
261
262 super(TestState, self).setUp()
263
264 self.hmm = build_hmm()
265 self.layer = self.hmm.layers[1]
266 self.m = self.hmm.layers[1][States.Match]
267 self.d = self.hmm.layers[1][States.Deletion]
268 self.i = self.hmm.layers[1][States.Insertion]
269 self.s = self.hmm.start
270
271 def testType(self):
272 self.assertEqual(self.m.type, States.Match)
273
274 def testTransitions(self):
275 # also covers TransitionTable and Transition
276 self.assertEqual(self.m.transitions.length, 3)
277 self.assertEqual(self.m.transitions[States.Match].predecessor, self.m)
278 self.assertEqual(self.m.transitions[States.Match].successor, self.hmm.layers[2][States.Match])
279 self.assertEqual(self.m.transitions[States.Match].probability, 0.8)
280 self.assertEqual(self.m.transitions[States.Insertion].type.source_state, States.Match)
281 self.assertEqual(self.m.transitions[States.Insertion].type.target_state, States.Insertion)
282
283 def testEmission(self):
284 # also covers EmissionTable
285 self.assertEqual(self.m.emission.length, 3)
286 self.assertEqual(set(self.m.emission), set([ProteinAlphabet.ALA, ProteinAlphabet.CYS, ProteinAlphabet.GLU]))
287 self.assertEqual(self.m.emission[ProteinAlphabet.CYS], 0.5)
288 self.assertRaises(KeyError, lambda: self.m.emission[ProteinAlphabet.GAP])
289 self.assertRaises(UnobservableStateError, lambda: self.d.emission)
290
291 self.m.emission.append(ProteinAlphabet.ILE, 0.5)
292 self.assertEqual(self.m.emission[ProteinAlphabet.ILE], 0.5)
293 self.m.emission.append('L', 0)
294 self.assertRaises(EmissionExistsError, lambda:self.m.emission.append('I', 0))
295 self.assertRaises(KeyError, lambda:self.m.emission.append('BUG', 0))
296
297 def testSilent(self):
298 self.assertTrue(self.d.silent)
299 self.assertFalse(self.m.silent)
300
301 def testBackground(self):
302 # also covers EmissionTable
303 self.assertEqual(self.m.background.length, 3)
304 self.assertEqual(set(self.m.background), set([ProteinAlphabet.ALA, ProteinAlphabet.CYS, ProteinAlphabet.GLU]))
305 self.assertEqual(self.m.background[ProteinAlphabet.CYS], 0.00325358)
306 self.assertRaises(KeyError, lambda: self.m.background[ProteinAlphabet.GAP])
307
308 self.m.background.append(ProteinAlphabet.ILE, 0.5)
309 self.assertEqual(self.m.background[ProteinAlphabet.ILE], 0.5)
310 self.m.background.append('L', 0)
311 self.assertRaises(EmissionExistsError, lambda:self.m.background.append('I', 0))
312 self.assertRaises(KeyError, lambda: self.m.background.append('BUG', 0))
313
314
315 @test.unit
316 class TestHit(test.Case):
317
318 def setUp(self):
319
320 super(TestHit, self).setUp()
321
322 self.h1 = HHpredHit(1, 'hit1', 2, 5, 3, 6, 0.5, 10)
323 self.h2 = HHpredHit(2, 'hit2', 3, 5, 4, 6, 0.2, 10)
324
325 def testEquals(self):
326 hit = HHpredHit(1, 'hit1', 2, 5, 3, 6, 0.5, 10)
327 self.assertTrue(self.h1.equals(hit))
328
329 def testSurpasses(self):
330 self.assertTrue(self.h1.surpasses(HHpredHit(5, 'hitX', 2, 3, 3, 4, 0.5, 10)))
331 self.assertTrue(self.h1.surpasses(HHpredHit(5, 'hitX', 2, 5, 3, 6, 0.3, 10)))
332
333 def testIncludes(self):
334 self.assertTrue(self.h1.includes(HHpredHit(5, 'hit1', 2, 3, 3, 4, 0.5, 10)))
335 self.assertTrue(self.h1.includes(HHpredHit(5, 'hit1', 2, 4, 3, 5, 0.3, 10)))
336 self.assertTrue(self.h1.includes(HHpredHit(5, 'hit1', 2, 8, 3, 9, 0.3, 10), tolerance=3))
337 self.assertFalse(self.h1.includes(HHpredHit(5, 'hit1', 2, 8, 3, 9, 0.3, 10), tolerance=2))
338 self.assertTrue(self.h1.includes(HHpredHit(5, 'hit1', 1, 5, 2, 6, 0.3, 10), tolerance=1))
339 self.assertFalse(self.h1.includes(HHpredHit(5, 'hit1', 1, 5, 2, 6, 0.3, 10), tolerance=0))
340
341 def testLength(self):
342 self.assertEqual(self.h1.length, 4)
343
344 def testAlignment(self):
345
346 q, s = 'AB-D', 'A-CD'
347 self.h1.add_alignment(q, s)
348
349 # query, subject
350 self.assertEqual(self.h1.alignment.query, q)
351 self.assertEqual(self.h1.alignment.subject, s)
352
353 # segments
354 segments = list(self.h1.alignment.segments)
355
356 self.assertEqual(len(segments), 2)
357 self.assertEqual(segments[0].qstart, 3)
358 self.assertEqual(segments[0].qend, 3)
359 self.assertEqual(segments[0].start, 2)
360 self.assertEqual(segments[0].end, 2)
361 self.assertEqual(segments[1].qstart, 5)
362 self.assertEqual(segments[1].qend, 5)
363 self.assertEqual(segments[1].start, 4)
364 self.assertEqual(segments[1].end, 4)
365
366 # to_a3m
367 a3m = self.h1.alignment.to_a3m().format(headers=False)
368 self.assertEqual(a3m.strip(), 'ABD\nA-cD')
369
370
371 @test.unit
372 class TestHitList(test.Case):
373
374 def setUp(self):
375
376 super(TestHitList, self).setUp()
377
378 self.h1 = HHpredHit(1, 'hit1', 2, 5, 3, 6, 0.5, 10)
379 self.h2 = HHpredHit(2, 'hit2', 3, 5, 4, 6, 0.2, 10)
380
381 self.h1.add_alignment('A-CD', 'A-CD')
382 self.h2.add_alignment('BCD', 'BCD')
383
384 self.hits = HHpredHitList([self.h1, self.h2])
385
386 def testLength(self):
387 self.assertEqual(len(self.hits), 2)
388
389 def testSort(self):
390 hits = HHpredHitList([self.h2, self.h1])
391
392 self.assertEqual(hits[0], self.h2)
393 self.assertEqual(hits[1], self.h1)
394 hits.sort()
395 self.assertEqual(hits[0], self.h1)
396 self.assertEqual(hits[1], self.h2)
397
398 def testIterator(self):
399 self.assertEqual(list(self.hits), [self.h1, self.h2])
400
401
402 if __name__ == '__main__':
403
404 test.Console()
405
406
407