Debian Codegraph @

csb/test/cases/statistics/pdf/parameterized.py

raw
1 import numpy
2 import csb.test as test
3
4 from csb.numeric import log
5
6 from csb.statistics.pdf.parameterized import ParameterizedDensity
7 from csb.statistics.pdf.parameterized import ParameterValueError, ParameterizationError
8 from csb.statistics.pdf.parameterized import AbstractParameter, Parameter, NonVirtualParameter
9
10
11
12 class Location(NonVirtualParameter):
13
14 def _validate(self, value):
15 return float(value)
16
17 class Scale(Parameter):
18
19 def _validate(self, value):
20 return float(value)
21
22 def _compute(self, base_value):
23
24 if base_value == 0.0:
25 return numpy.inf
26 else:
27 return 1.0 / base_value ** 0.5
28
29 def bind_to(self, base):
30
31 if base.name != "precision":
32 raise ValueError(base)
33
34 super(Scale, self).bind_to(base)
35
36 class DoubleScale(Parameter):
37
38 def _validate(self, value):
39 return float(value)
40
41 def _compute(self, base_value):
42 return base_value * 2.0
43
44 class Precision(Parameter):
45
46 def _validate(self, value):
47
48 if value < 0:
49 raise ParameterValueError(self.name, value)
50 return float(value)
51
52
53 class FancyGaussian(ParameterizedDensity):
54
55 def __init__(self, mu=0, precision=1):
56
57 super(FancyGaussian, self).__init__()
58
59 self._register('mu')
60 self._register('sigma')
61 self._register('precision')
62
63 loc = Location(mu)
64 prec = Precision(precision)
65 sigma = Scale(0)
66 sigma.bind_to(prec)
67
68 self.set_params(mu=loc, sigma=sigma, precision=prec)
69
70 @property
71 def mu(self):
72 return self['mu'].value
73
74 @property
75 def sigma(self):
76 return self['sigma'].value
77
78 @property
79 def precision(self):
80 return self['precision'].value
81
82 def log_prob(self, x):
83
84 mu = self.mu
85 sigma = self.sigma
86
87 return log(1.0 / numpy.sqrt(2 * numpy.pi * sigma ** 2)) - (x - mu) ** 2 / (2 * sigma ** 2)
88
89
90 @test.unit
91 class TestAbstractGenericParameter(test.Case):
92 """
93 Use AbstractParameter as a generic class which accepts values
94 of any type.
95 """
96
97 def setUp(self):
98
99 class Value(object):
100 pass
101
102 class Param(AbstractParameter):
103
104 def _validate(self, value):
105 if not isinstance(value, Value):
106 raise TypeError(value)
107 return value
108
109 self.value = Value()
110 self.param = Param(self.value)
111
112 def testValue(self):
113 self.assertIs(self.param.value, self.value)
114
115 def testSet(self):
116 self.assertRaises(TypeError, self.param.set, 3)
117
118
119 @test.unit
120 class TestParameter(test.Case):
121 """
122 This is the main test case with complete coverage for AbstractParameter's
123 methods and behavior. Covers also Parameter.
124
125 computed -- leaf
126 /
127 base -- computed2
128 \
129 computed3
130 """
131
132 def setUp(self):
133 self.base = Precision(1.2)
134 self.computed = Scale(100, base=self.base)
135 self.computed2 = Scale(200, base=self.base)
136 self.computed3 = Scale(300, base=self.base)
137 self.leaf = DoubleScale(400, base=self.computed)
138
139 def testConstrucor(self):
140 # make sure newly constructed parameters are left in a consistent state
141 # to avoid unnecessary consistency updates
142 self.assertTrue(self.base._consistent)
143 self.assertTrue(Scale(1)._consistent)
144
145 def testName(self):
146
147 self.assertEqual(self.base.name, "precision")
148 self.assertEqual(self.computed.name, "scale")
149 self.assertEqual(Scale(name="TesT").name, "TesT")
150
151 def testValue(self):
152
153 self.assertEqual(self.base.value, 1.2)
154 self.assertEqual(self.computed.value, 1.0 / numpy.sqrt(self.base.value))
155 self.assertEqual(self.computed2.value, 1.0 / numpy.sqrt(self.base.value))
156 self.assertEqual(self.leaf.value, self.computed.value * 2)
157
158 # turn self.base into a virtual parameter
159 self.base.bind_to(Precision(12.2))
160 self.assertEqual(self.base.value, 12.2)
161
162 def testIsVirtual(self):
163
164 self.assertFalse(self.base.is_virtual)
165 self.assertTrue(self.computed.is_virtual)
166
167 self.base.bind_to(Precision(12.2))
168 self.assertTrue(self.base.is_virtual)
169
170 def testSet(self):
171
172 base_initial_value = self.base._value
173
174 # recompute all derivatives from the initial value of base
175 self.assertEqual(self.computed._value, 100)
176 self.leaf._ensure_consistency()
177 self.computed2._ensure_consistency()
178 self.computed3._ensure_consistency()
179
180 # set self.base - it should remain consistent because it is not computed
181 self.assertTrue(self.base._consistent)
182 self.base.set(2.2)
183 self.assertTrue(self.base._consistent)
184 self.assertEqual(self.base.value, 2.2)
185
186 # self.computed and self.leaf should be inconsistent now that their base is updated
187 self.assertFalse(self.computed._consistent)
188 self.assertFalse(self.leaf._consistent)
189 self.assertEqual(self.computed._value, 1.0 / numpy.sqrt(base_initial_value))
190 self.assertEqual(self.leaf._value, 2.0 / numpy.sqrt(base_initial_value))
191 # retrieving self.computed's value should trigger updates up to self.computed
192 recomputed = self.computed.value
193 self.assertTrue(self.computed._consistent)
194 self.assertEqual(recomputed, 1.0 / numpy.sqrt(self.base._value))
195 # self.leaf is still inconsistent
196 self.assertFalse(self.leaf._consistent)
197 self.assertEqual(self.leaf._value, 2.0 / numpy.sqrt(base_initial_value))
198 self.assertIs(self.leaf._nearest_consistent_base()[-1], self.computed)
199 # until we request its value
200 recomputed = self.leaf.value
201 self.assertTrue(self.leaf._consistent)
202 self.assertEqual(recomputed, 2.0 / numpy.sqrt(self.base._value))
203 self.assertEqual(recomputed, 2.0 * self.computed._value)
204 # make sure the other two branches are still inconsistent
205 initial_value = 1.0 / numpy.sqrt(base_initial_value)
206 self.assertEqual(self.computed2._value, initial_value)
207 self.assertEqual(self.computed3._value, initial_value)
208 # until they get used
209 recomputed = self.computed2.value
210 self.assertTrue(self.computed2._consistent)
211 self.assertEqual(recomputed, 1.0 / numpy.sqrt(self.base._value))
212
213 # attempt to set self.computed - not allowed
214 self.assertRaises(ParameterizationError, self.computed.set, 2)
215
216 # attempt to set a negative Precision
217 self.assertRaises(ParameterValueError, self.base.set, -2)
218 # attempt to assigned non-float - not allowed in the Parameter specialization
219 self.assertRaises(ParameterValueError, Parameter().set, object())
220
221 def testBindTo(self):
222
223 # can't bind self.base to itself
224 self.assertRaises(ParameterizationError, self.base.bind_to, self.base)
225 # deeper circular dependency
226 self.assertRaises(ParameterizationError, self.base.bind_to, self.computed)
227
228 # self.base is not virtual and therefore must be consistent
229 self.assertTrue(self.base._consistent)
230
231 # make it virtual - should get inconsistent now
232 self.base.bind_to(Precision(12.2))
233 self.assertFalse(self.base._consistent)
234 self.assertTrue(self.base.is_virtual)
235
236 # retrieving its value should trigger the consistency cascade
237 self.assertEqual(self.base.value, 12.2)
238 self.assertTrue(self.base._consistent)
239
240 def testFindBaseParameter(self):
241
242 self.assertIs(self.base.find_base_parameter(), self.base)
243 self.assertIs(self.computed.find_base_parameter(), self.base)
244
245
246 @test.unit
247 class TestNonVirtualParameter(test.Case):
248 """
249 Make sure explicit NonVirtualParameter-s are updatable and
250 refuse binding requests
251 """
252
253 def setUp(self):
254 self.param = Location()
255
256 def testConstructor(self):
257 base = Parameter()
258 self.assertRaises(ParameterizationError, lambda: Location(base=base))
259
260 def testIsVirtual(self):
261 self.assertFalse(self.param.is_virtual)
262
263 def testBindTo(self):
264 base = Parameter()
265 self.assertRaises(ParameterizationError, self.param.bind_to, base)
266
267 def testSet(self):
268 self.param.set(22)
269 self.assertEqual(self.param.value, 22)
270
271
272 @test.unit
273 class TestParameterizedDensity(test.Case):
274
275 def setUp(self):
276 self.pdf = FancyGaussian(2, 5)
277
278 def testConstructor(self):
279
280 class Density(ParameterizedDensity):
281
282 def __init__(self, p):
283 super(Density, self).__init__()
284 self._register('p')
285 self.set_params(p=p)
286
287 def log_prob(self, x):
288 return x
289
290 self.assertRaises(TypeError, Density, 4)
291
292 def testProperties(self):
293
294 self.assertEqual(self.pdf.mu, 2)
295 self.assertEqual(self.pdf.precision, 5)
296 self.assertAlmostEqual(self.pdf.sigma, 0.4472, places=3)
297
298 def testParameterChaining(self):
299
300 self.assertEqual(self.pdf.precision, 5)
301 self.assertAlmostEqual(self.pdf.sigma, 0.4472, places=3)
302
303 self.pdf['precision'].set(2)
304
305 self.assertEqual(self.pdf.precision, 2)
306 self.assertAlmostEqual(self.pdf.sigma, 0.7071, places=3)
307
308 def testAssignment(self):
309
310 self.pdf['sigma'] = Scale(55)
311 self.assertEqual(self.pdf.sigma, 55)
312 self.assertEqual(self.pdf['sigma'].name, 'scale')
313
314 def assign(i):
315 self.pdf['sigma'] = i
316
317 self.assertRaises(TypeError, assign, 55)
318
319
320
321 if __name__ == '__main__':
322 test.Console()
323