Debian Codegraph @

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

raw
1
2 import numpy
3 import numpy.random
4
5 import csb.test as test
6
7 from csb.statistics.pdf import ParameterValueError, EstimationFailureError
8 from csb.statistics.pdf import Normal, GeneralizedNormal, Laplace, Gamma, InverseGamma, GumbelMaximum, GumbelMinimum
9 from csb.statistics.pdf import MultivariateGaussian, Dirichlet, InverseGaussian, GeneralizedInverseGaussian
10
11
12 @test.regression
13 class TestDensityRegressions(test.Case):
14
15 def testParameterValidation(self):
16 """
17 @see: [CSB 0000132]
18 """
19 self.assertRaises(ParameterValueError, InverseGaussian, -1, 1)
20
21 pdf = InverseGaussian()
22 data = [ 3.1, 1.15, 6.86, 0.69, -1.73, -2.91, -2.2800744]
23
24 def testMu(v):
25 pdf['mu'] = v
26 pdf.mu = v
27
28 self.assertRaises(ParameterValueError, testMu, -1)
29 self.assertRaises(EstimationFailureError, pdf.estimate, data)
30
31
32 @test.unit
33 class TestNormal(test.Case):
34
35 def testParameters(self):
36
37 pdf = Normal(2.5, 1.5)
38 pdf.mu = 33
39 pdf.sigma = 44
40
41 self.assertEqual(pdf.mu, 33)
42 self.assertEqual(pdf.sigma, 44)
43 self.assertEqual(pdf.sigma, pdf['sigma'])
44
45 def testLogProb(self):
46
47 n = Normal(0, 1)
48
49 self.assertAlmostEqual(n(0.), 1. / numpy.sqrt(2 * numpy.pi), delta=1e-1)
50 self.assertAlmostEqual(n(1.), numpy.exp(-0.5) / numpy.sqrt(2 * numpy.pi), delta=1e-1)
51
52 def testParameterEstimation(self):
53
54 mu, sigma = 2.2, 0.3
55 data = numpy.random.normal(mu, sigma, 100000)
56
57 pdf = Normal(1, 1)
58 pdf.estimate(data)
59
60 self.assertAlmostEqual(pdf.mu, mu, delta=0.05)
61 self.assertAlmostEqual(pdf.sigma, sigma, delta=0.05)
62
63 def testRandom(self):
64
65 pdf = Normal(4, 2)
66 data = pdf.random(100000)
67
68 self.assertAlmostEqual(numpy.mean(data), pdf.mu, delta=0.05)
69 self.assertAlmostEqual(numpy.std(data), pdf.sigma, delta=0.05)
70
71
72 @test.unit
73 class TestLaplace(test.Case):
74
75 def testParameters(self):
76
77 pdf = Laplace(1.5, 2.5)
78 pdf.mu = 33
79 pdf.b = 44
80
81 self.assertEqual(pdf.mu, 33)
82 self.assertEqual(pdf.b, 44)
83 self.assertEqual(pdf.b, pdf['b'])
84
85 def propertyAssignment():
86 pdf.b = -1
87 def directAssignment():
88 pdf['b'] = -1
89
90 self.assertRaises(ParameterValueError, propertyAssignment)
91 self.assertRaises(ParameterValueError, directAssignment)
92
93 def testLogProb(self):
94
95 pdf = Laplace(0, 2)
96 self.assertEqual(pdf(0), 1.0 / (2 * pdf.b))
97 self.assertEqual(pdf(1), 1 / (2 * pdf.b) * numpy.exp(-1 / pdf.b))
98
99 def testParameterEstimation(self):
100
101 mu, b = 2.2, 2
102 data = numpy.random.laplace(mu, b, 100000)
103
104 pdf = Laplace(1, 1)
105 pdf.estimate(data)
106
107 self.assertAlmostEqual(pdf.mu, mu, places=1)
108 self.assertAlmostEqual(pdf.b, b, places=1)
109
110 def testRandom(self):
111
112 pdf = Laplace(4, 2)
113 data = pdf.random(100000)
114
115 self.assertAlmostEqual(numpy.median(data), pdf.mu, delta=0.05)
116
117
118 @test.unit
119 class TestInverseGaussian(test.Case):
120
121 def testParameters(self):
122
123 pdf = InverseGaussian(1.5, 2.5)
124 pdf.mu = 3
125 pdf.shape = 4
126
127 self.assertEqual(pdf.mu, 3)
128 self.assertEqual(pdf.shape, 4)
129 self.assertEqual(pdf.mu, pdf['mu'])
130
131 def propertyAssignment():
132 pdf.shape = -1
133 def directAssignment():
134 pdf['shape'] = -1
135
136 self.assertRaises(ParameterValueError, propertyAssignment)
137 self.assertRaises(ParameterValueError, directAssignment)
138
139 def testLogProb(self):
140
141 ig = InverseGaussian(1., 1.)
142
143 self.assertAlmostEqual(ig(1.), numpy.sqrt(1 / (2 * numpy.pi)), delta=1e-5)
144 self.assertAlmostEqual(ig(2.), (numpy.sqrt(1 / (2 * numpy.pi * 2 ** 3)) *
145 numpy.exp(-1. / 4.)), delta=1e-5)
146
147 def testParameterEstimation(self):
148
149 mu, shape = 1, 3
150 data = numpy.random.wald(mu, shape, 100000)
151
152 pdf = InverseGaussian(1, 1)
153 pdf.estimate(data)
154
155 self.assertAlmostEqual(pdf.mu, mu, places=2)
156 self.assertAlmostEqual(pdf.shape, shape, delta=0.05)
157
158 def testRandom(self):
159
160 ig = InverseGaussian(1., 1.)
161 samples = ig.random(1000000)
162 mu = numpy.mean(samples)
163 var = numpy.var(samples)
164
165 self.assertAlmostEqual(ig.mu, mu, delta=1e-1)
166 self.assertAlmostEqual(ig.mu ** 3 / ig.shape, var, delta=1e-1)
167
168 ig = InverseGaussian(3., 6.)
169
170 samples = ig.random(1000000)
171 mu = numpy.mean(samples)
172 var = numpy.var(samples)
173
174 self.assertAlmostEqual(ig.mu, mu, delta=1e-1)
175 self.assertAlmostEqual(ig.mu ** 3 / ig.shape, var, delta=5e-1)
176
177
178 @test.unit
179 class TestGeneralizedNormal(test.Case):
180
181 def testParameters(self):
182
183 pdf = GeneralizedNormal(0, 1, 1)
184 pdf.mu = 11
185 pdf.alpha = 2
186 pdf.beta = 3
187
188 self.assertEqual(pdf.mu, 11)
189 self.assertEqual(pdf.alpha, 2)
190 self.assertEqual(pdf.beta, 3)
191 self.assertEqual(pdf.beta, pdf['beta'])
192
193 def propertyAssignment():
194 pdf.beta = -1
195 def directAssignment(p):
196 pdf[p] = -1
197
198 self.assertRaises(ParameterValueError, propertyAssignment)
199 self.assertRaises(ParameterValueError, directAssignment, 'alpha')
200 self.assertRaises(ParameterValueError, directAssignment, 'beta')
201
202 def testLogProb(self):
203
204 from scipy.special import gamma
205
206 pdf = GeneralizedNormal(0, 1, 1)
207 a = pdf.alpha
208 b = pdf.beta
209
210 self.assertEqual(pdf(0), b / (2 * a * gamma(1 / b)))
211 self.assertAlmostEqual(pdf(1), 1. / (2 * gamma(1)) * numpy.exp(-1), delta=1e-5)
212
213 def testParameterEstimation(self):
214
215 mu, alpha, beta = -0.04, 2.11, 1.90
216 data = [-1.1712, -2.5608, -0.7143, 2.6218, -2.0655, 0.7544, 1.208, -0.5289, 0.0045, 1.1746,
217 -1.0766, 1.1198, 1.2785, -0.6051, 2.2913, -3.6672, -0.2525, 0.8782, -0.0617, -0.0239]
218
219 pdf = GeneralizedNormal(1, 1, 1)
220 pdf.estimate(data)
221
222 self.assertAlmostEqual(pdf.mu, mu, places=2)
223 self.assertAlmostEqual(pdf.alpha, alpha, places=2)
224 self.assertAlmostEqual(pdf.beta, beta, places=1)
225
226
227 @test.unit
228 class TestGeneralizedInverseGaussian(test.Case):
229
230 def testParameters(self):
231
232 pdf = GeneralizedInverseGaussian(1, 1, 1)
233 pdf.a = 2
234 pdf.b = 3
235 pdf.p = 4
236
237 self.assertEqual(pdf.a, 2)
238 self.assertEqual(pdf.b, 3)
239 self.assertEqual(pdf.p, 4)
240 self.assertEqual(pdf.p, pdf['p'])
241
242 def propertyAssignment():
243 pdf.a = -1
244 def directAssignment(p):
245 pdf[p] = -1
246
247 self.assertRaises(ParameterValueError, propertyAssignment)
248 self.assertRaises(ParameterValueError, directAssignment, 'a')
249 self.assertRaises(ParameterValueError, directAssignment, 'b')
250 self.assertRaises(ParameterValueError, directAssignment, 'p')
251
252 def testLogProb(self):
253
254 fx = [2.7939e-24, 1.5305e-03, 2.3028e-02, 6.6302e-02, 1.1759e-01, 1.6810e-01,
255 2.1365e-01, 2.5255e-01, 2.8438e-01, 3.0937e-01, 3.2806e-01, 3.4111e-01,
256 3.4922e-01, 3.5307e-01, 3.5329e-01, 3.5048e-01, 3.4515e-01, 3.3778e-01,
257 3.2878e-01, 3.1850e-01, 3.0726e-01, 2.9531e-01, 2.8289e-01, 2.7018e-01,
258 2.5736e-01, 2.4454e-01, 2.3185e-01, 2.1937e-01, 2.0717e-01, 1.9532e-01,
259 1.8385e-01, 1.7280e-01, 1.6220e-01, 1.5205e-01, 1.4236e-01, 1.3315e-01,
260 1.2440e-01, 1.1611e-01, 1.0828e-01, 1.0088e-01, 9.3917e-02, 8.7363e-02,
261 8.1207e-02, 7.5432e-02, 7.0021e-02, 6.4958e-02, 6.0224e-02, 5.5804e-02]
262
263 x = numpy.arange(0.01, 5., 0.1)
264
265 a = 2.
266 b = 1.
267 p = 2
268 gig = GeneralizedInverseGaussian(a, b, p)
269 fx2 = gig(x)
270
271 for i in range(len(fx)):
272 self.assertAlmostEqual(fx[i], fx2[i], delta=1e-1)
273
274 def testRandom(self):
275
276 from scipy.special import kv
277 from numpy import sqrt
278
279 a = 2.
280 b = 1.
281 p = 1
282 gig = GeneralizedInverseGaussian(a, b, p)
283 samples = gig.random(10000)
284
285 mu_analytical = sqrt(b) * kv(p + 1, sqrt(a * b)) / (sqrt(a) * kv(p, sqrt(a * b)))
286
287 var_analytical = b * kv(p + 2, sqrt(a * b)) / a / kv(p, sqrt(a * b)) - mu_analytical ** 2
288
289 mu = numpy.mean(samples)
290 var = numpy.var(samples)
291
292 self.assertAlmostEqual(mu_analytical, mu, delta=1e-1)
293 self.assertAlmostEqual(var_analytical, var, delta=1e-1)
294
295
296 @test.unit
297 class TestGamma(test.Case):
298
299 def testParameters(self):
300
301 pdf = Gamma(1, 1)
302 pdf.alpha = 2
303 pdf.beta = 3
304
305 self.assertEqual(pdf.alpha, 2)
306 self.assertEqual(pdf.beta, 3)
307 self.assertEqual(pdf.beta, pdf['beta'])
308
309 def propertyAssignment():
310 pdf.beta = -1
311 def directAssignment(p):
312 pdf[p] = -1
313
314 self.assertRaises(ParameterValueError, propertyAssignment)
315 self.assertRaises(ParameterValueError, directAssignment, 'alpha')
316 self.assertRaises(ParameterValueError, directAssignment, 'beta')
317
318 def testLogProb(self):
319
320 g = Gamma(1., 1.)
321 self.assertAlmostEqual(g(1.), numpy.exp(-1.), delta=1e-5)
322 self.assertAlmostEqual(g(2.), numpy.exp(-2.), delta=1e-5)
323
324 g = Gamma(2., 1.)
325 self.assertAlmostEqual(g(1.), 1. * numpy.exp(-1), delta=1e-5)
326 self.assertAlmostEqual(g(2.), 2. * numpy.exp(-2), delta=1e-5)
327
328 def testParameterEstimation(self):
329
330 alpha = 0.1
331 beta = 0.1
332
333 data = numpy.random.gamma(alpha, 1. / beta, 10000)
334 pdf = Gamma(1, 1)
335 pdf.estimate(data)
336
337 self.assertAlmostEqual(pdf.alpha, alpha, places=2)
338 self.assertAlmostEqual(pdf.beta, beta, places=1)
339
340 def testRandom(self):
341
342 gamma = Gamma(1., 1.)
343 samples = gamma.random(10000)
344 mu = numpy.mean(samples)
345 var = numpy.var(samples)
346
347 self.assertAlmostEqual(gamma.alpha / gamma.beta, mu, delta=1e-1)
348 self.assertAlmostEqual(gamma.alpha / gamma.beta ** 2, var, delta=1e-1)
349
350
351 @test.unit
352 class TestInverseGamma(test.Case):
353
354 def testParameters(self):
355
356 pdf = InverseGamma(1, 1)
357 pdf.alpha = 2
358 pdf.beta = 3
359
360 self.assertEqual(pdf.alpha, 2)
361 self.assertEqual(pdf.beta, 3)
362 self.assertEqual(pdf.beta, pdf['beta'])
363
364 def propertyAssignment():
365 pdf.beta = -1
366 def directAssignment(p):
367 pdf[p] = -1
368
369 self.assertRaises(ParameterValueError, propertyAssignment)
370 self.assertRaises(ParameterValueError, directAssignment, 'alpha')
371 self.assertRaises(ParameterValueError, directAssignment, 'beta')
372
373 def testLogProb(self):
374
375 ig = InverseGamma(1., 1.)
376 self.assertAlmostEqual(ig(1.), numpy.exp(-1.), delta=1e-5)
377 self.assertAlmostEqual(ig(2.), 2 ** -2 * numpy.exp(-0.5), delta=1e-5)
378
379 ig = InverseGamma(2., 1.)
380 self.assertAlmostEqual(ig(1.), 1. * numpy.exp(-1), delta=1e-5)
381 self.assertAlmostEqual(ig(2.), 2.** -3 * numpy.exp(-0.5), delta=1e-5)
382
383
384 @test.unit
385 class TestMultivariateGaussian(test.Case):
386
387 def testParameters(self):
388
389 pdf = MultivariateGaussian(numpy.zeros(3), numpy.eye(3))
390 d = 2
391 pdf.mu = numpy.zeros(d)
392 pdf.sigma = numpy.eye(d)
393
394 self.assertEqual(list(pdf.mu), [0, 0])
395 self.assertEqual(pdf.sigma.tolist(), numpy.eye(d).tolist())
396
397 def testLogProb(self):
398
399 mg = MultivariateGaussian(numpy.zeros(2), numpy.eye(2))
400
401 self.assertAlmostEqual(mg(numpy.zeros(2)), 1. / (2 * numpy.pi), delta=1e-1)
402 self.assertAlmostEqual(mg(numpy.ones(2)), 1. / (2 * numpy.pi) * numpy.exp(-0.5), delta=1e-1)
403
404 def testParameterEstimation(self):
405
406 d = 3
407 mu = numpy.ones(d)
408 sigma = numpy.eye(d)
409
410 pdf = MultivariateGaussian(mu, sigma)
411 samples = pdf.random(100000)
412 pdf.estimate(samples)
413
414 for i in range(d):
415 self.assertAlmostEqual(pdf.mu[i], mu[i], delta=1e-1)
416 for j in range(d):
417 self.assertAlmostEqual(pdf.sigma[i, j], sigma[i, j], delta=1e-1)
418
419
420 d = 3
421 mu = numpy.array([0., 1., 2.])
422 sigma = numpy.random.random((d, d))
423 sigma = numpy.dot(sigma, sigma.T)
424 pdf = MultivariateGaussian(mu, sigma)
425 samples = pdf.random(1000000)
426 pdf.estimate(samples)
427
428 for i in range(d):
429 self.assertAlmostEqual(pdf.mu[i], mu[i], delta=1e-1)
430 for j in range(d):
431 self.assertAlmostEqual(pdf.sigma[i, j], sigma[i, j], delta=1e-1)
432
433
434 @test.unit
435 class TestDirichlet(test.Case):
436
437 def testParameters(self):
438
439 pdf = Dirichlet([1, 1])
440
441 alpha = numpy.array([2, 2])
442 pdf.alpha = numpy.array([2, 2])
443
444 self.assertEqual(pdf.alpha.tolist(), alpha.tolist())
445 self.assertEqual(pdf.alpha.tolist(), pdf['alpha'].tolist())
446
447 def testLogProb(self):
448
449 alpha = numpy.array([2, 2])
450 pdf = Dirichlet(alpha)
451
452 x = numpy.array([0.5, 0.5])
453 self.assertAlmostEqual(pdf(x), 1.5, places=2)
454
455 x = numpy.array([0.1, 0.9])
456 self.assertAlmostEqual(pdf(x), .54, places=2)
457
458 x = numpy.array([0.9, 0.1])
459 self.assertAlmostEqual(pdf(x), .54, places=2)
460
461 x = numpy.array([[0.9, 0.1],
462 [0.1, 0.9],
463 [0.5, 0.5]])
464
465 self.assertAlmostEqual(pdf(x)[0], .54, places=2)
466 self.assertAlmostEqual(pdf(x)[1], .54, places=2)
467 self.assertAlmostEqual(pdf(x)[2], 1.5, places=2)
468
469 def testParameterEstimation(self):
470
471 alpha = numpy.array([1., 1., 1.])
472 pdf = Dirichlet(alpha)
473
474 self.assertAlmostEqual(pdf(numpy.array([1., 0., 0])),
475 pdf(numpy.array([0., 1., 0])),
476 delta=1e-1)
477
478 self.assertAlmostEqual(pdf(numpy.array([1. / 3., 1. / 3., 1. / 3])),
479 pdf(numpy.array([0., 1., 0])),
480 delta=1e-1)
481
482 alpha = numpy.array([16., 16., 16.])
483 pdf = Dirichlet(alpha)
484
485
486 self.assertAlmostEqual(pdf(numpy.array([1., 0., 0])),
487 pdf(numpy.array([0., 1., 0])),
488 delta=1e-1)
489
490 self.assertAlmostEqual(pdf(numpy.array([1., 0., 0])),
491 pdf(numpy.array([0., 0., 1])),
492 delta=1e-1)
493
494 self.assertNotEqual(pdf(numpy.array([1. / 3., 1. / 3., 1. / 3])),
495 pdf(numpy.array([0., 1., 0])))
496
497 alpha = numpy.array([1., 1., 1.])
498 pdf = Dirichlet(alpha)
499
500 samples = pdf.random(100000)
501 pdf.estimate(samples)
502
503 for i in range(len(alpha)):
504 self.assertAlmostEqual(pdf.alpha[i], alpha[i], delta=1e-1)
505
506
507 alpha = numpy.array([200., 60., 20.])
508 pdf = Dirichlet(alpha)
509
510 samples = pdf.random(100000)
511 pdf.estimate(samples)
512
513 for i in range(len(alpha)):
514 self.assertAlmostEqual(pdf.alpha[i], alpha[i], delta=1e1)
515
516
517 @test.unit
518 class TestGumbelMinimum(test.Case):
519
520 @property
521 def klass(self):
522 return GumbelMinimum
523
524 def testParameters(self):
525
526 pdf = self.klass(1, 1)
527 pdf.mu = 2
528 pdf.beta = 3
529
530 self.assertEqual(pdf.mu, 2)
531 self.assertEqual(pdf.beta, 3)
532 self.assertEqual(pdf.beta, pdf['beta'])
533
534 def propertyAssignment():
535 pdf.beta = -1
536 def directAssignment():
537 pdf['beta'] = -1
538
539 self.assertRaises(ParameterValueError, propertyAssignment)
540 self.assertRaises(ParameterValueError, directAssignment)
541
542 def testLogProb(self):
543
544 pdf = self.klass(0, 2)
545 self.assertAlmostEqual(pdf(0), 1.0 / (pdf.beta * numpy.e))
546
547 def testParameterEstimation(self):
548
549 mu, beta = 4, 2
550 data = -numpy.random.gumbel(-mu, beta, 1000000)
551
552 pdf = GumbelMinimum(1, 1)
553 pdf.estimate(data)
554
555 self.assertAlmostEqual(pdf.mu, mu, delta=0.01)
556 self.assertAlmostEqual(pdf.beta, beta, delta=0.01)
557
558 def testRandom(self):
559
560 pdf = self.klass(4, 2)
561 data = pdf.random(100000)
562
563 beta = numpy.sqrt(6 * numpy.var(data)) / numpy.pi
564 self.assertAlmostEqual(pdf.beta, beta, delta=0.05)
565
566
567 @test.unit
568 class TestGumbelMaximum(TestGumbelMinimum):
569
570 @property
571 def klass(self):
572 return GumbelMaximum
573
574 def testParameterEstimation(self):
575
576 mu, beta = 1, 2
577 data = numpy.random.gumbel(mu, beta, 1000000)
578
579 pdf = GumbelMaximum(1, 1)
580 pdf.estimate(data)
581
582 self.assertAlmostEqual(pdf.mu, mu, delta=0.01)
583 self.assertAlmostEqual(pdf.beta, beta, delta=0.01)
584
585
586 if __name__ == '__main__':
587
588 test.Console()
589