class TestAdjacentRegression(TestReferenceRegression): _eta = linalg.Vector([2.7, 4.]) _canonical_link = glm.OrdinalLink(ratio='adjacent') _norm = 1 + math.exp(_eta[0] + _eta[1]) + math.exp(_eta[1]) _mu = linalg.Vector([ math.exp(_eta[0] + _eta[1]) / _norm, math.exp(_eta[1]) / _norm, 1 / _norm ]) _categories = ['C', 'B', 'A'] @classmethod def setUpClass(cls): """Test adjacent regression construction""" cls.predictor_init() oss = core.OrdinalSampleSpace(*cls._categories) cls._model = glm.OrdinalRegression(oss, cls._pred, cls._canonical_link) def test_conditional(self): """Test ordinal regression conditional operator""" response_distribution = self._model(*self._x) self.assertAlmostEqual(response_distribution.pdf('C'), self._mu[0], places=self._places) self.assertAlmostEqual(response_distribution.pdf('B'), self._mu[1], places=self._places) self.assertAlmostEqual(response_distribution.pdf('A'), self._mu[2], places=self._places) @classmethod def tearDownClass(cls): """Test adjacent regression deletion""" del cls._model
class TestCumulativeRegressionEstimation( TestCanonicalOrdinalRegressionEstimation): _alpha = linalg.Vector([0.044, 1.655]) _delta = linalg.Vector([0.576, -1.147, -2.232]) # (Dosbson, 2008) page 161 _loglikelihood = -290.648 def test_Fisher(self): """Test Fisher scoring estimation for cumulative regression with proportional design""" #import ipdb #ipdb.set_trace() # beta_init = linalg.Vector([-0.66, 0.66, 0., 0., 0.]) # mle = glm.ordinal_estimation(ratio='cumulative', Z='proportional', data=self._data, response = 0, explanatories = {1,2}, beta_init=beta_init) mle = glm.ordinal_estimation(ratio='cumulative', Z='proportional', data=self._data, response=0, explanatories={1, 2}) alpha = mle.estimated.predictor.alpha delta = mle.estimated.predictor.delta self.assertAlmostEqual(mle.loglikelihood, self._loglikelihood, places=3) for i in range(len(self._alpha)): self.assertAlmostEqual(alpha[i], self._alpha[i], places=3) for i in range(len(self._delta)): self.assertAlmostEqual(delta[i], self._delta[i], places=3)
class TestSequentialRegressionEstimation( TestCanonicalOrdinalRegressionEstimation): _alpha = linalg.Vector([11.127, 10.915]) _delta = linalg.Vector( [-0.377, 0.49, -0.128, -0.424, -0.062]) # (Tutz, 2012) page 255 - results are truncated at 10^{-3} - @classmethod def setUpClass(cls): """Test multivariate data construction""" cls._data = data.load('retinopathy') def test_Fisher(self): """Test Fisher scoring estimation for ordinal regression with proportional design""" mle = glm.ordinal_estimation(ratio='sequential', Z='constrained', data=self._data, response=0, explanatories={1, 2, 3, 4}, partial_proportional={1, 2, 3}) alpha = mle.estimated.predictor.alpha delta = mle.estimated.predictor.delta for i in range(len(self._alpha)): x = int(alpha[i] * 1000) / float(1000) self.assertEqual(x, self._alpha[i]) for i in range(len(self._delta)): x = int(delta[i] * 1000) / float(1000) self.assertEqual(x, self._delta[i])
class TestCompleteVectorPredictor(unittest.TestCase, TestPredictor): _alpha = linalg.Vector([1., 2.]) _delta = linalg.Matrix([[0.5, 2.], [1., 4.]]) _len = 6 _eta = linalg.Vector([4.7, 9.4]) @classmethod def setUpClass(cls): """Test complete vector predictor construction""" cls.sample_space_init() cls._pred = glm.CompleteVectorPredictor(cls._vector_sample_spaces, 2) def test_predictor(self): """Test vector predictor operator""" self._pred.alpha = self._alpha self._pred.delta = self._delta self.assertEqual(len(self._pred), self._len) eta = self._pred(1, 1.6) self.assertEqual(eta[0], self._eta[0]) self.assertEqual(eta[1], self._eta[1]) @classmethod def tearDownClass(cls): """Test complete vector predictor deletion""" del cls._pred
def test_column_construction(self): """Test column vector construction""" self.assertEqual(self._C.nb_rows, 3) self.assertEqual(self._C.nb_cols, 1) for element in self._C: self.assertEqual(element, 0.) self.assertEqual(self._C, linalg.Vector(3)) self.assertEqual(self._C, linalg.Vector(self._C))
def test_get_set(self): """Test Ordinal distribution get and set ordered pi and oredered values""" self.assertEqual(self._dist_unif.pdf('B'), 1 / 3.) self.assertEqual(self._dist_unif.cdf('B'), 2 / 3.) self.assertEqual(self._dist_unif.ldf('B'), math.log(1 / 3.)) self.assertEqual(tuple(self._dist.ordered_values), ('C', 'B', 'A')) self.assertEqual(self._dist.ordered_pi, linalg.Vector([1 / 3., 1 / 6., 0.5])) self.assertEqual(self._dist.pi, linalg.Vector([0.5, 1 / 6., 1 / 3.])) self.assertEqual(self._dist.pdf('B'), 1 / 6.) self.assertEqual(self._dist.cdf('B'), 1 / 2.) self.assertEqual(self._dist.ldf('B'), math.log(1 / 6.))
class TestConstrainedRegressionEstimation( TestCanonicalNominalRegressionEstimation): _alpha = linalg.Vector([7.3348, 3.5917, 4.3719]) _delta = linalg.Vector([-0.0235, -0.1002, 0.0238, -1.1738]) # (Louviere et al., 2000) page 157 _slope_constraint = linalg.Matrix([[1, 0, 0, 0], [0, 0, 0, 0], [-1, 0, 0, 0], [0, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, -1, 0, 0], [0, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [0, 0, 0, 0], [1, 0, 0, 0], [-1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 1, 0, 0], [0, -1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [-1, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, -1, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]) @classmethod def setUpClass(cls): """Test multivariate data construction""" cls._data = data.load('travel') cls._data.TravelMode.sample_space.reference = "car" def test_Fisher(self): """Test Fisher scoring estimation for nominal regression with constrained design""" mle = glm.nominal_estimation( Z='constrained', data=self._data, response=0, explanatories={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, slope_constraint=self._slope_constraint) alpha = mle.estimated.predictor.alpha delta = mle.estimated.predictor.delta for i in range(len(self._alpha)): self.assertAlmostEqual(alpha[i], self._alpha[i], places=4) for i in range(len(self._delta)): self.assertAlmostEqual(delta[i], self._delta[i], places=4) #mle_normal = glm.nominal_estimation(distribution=core.NormalDistribution(), Z='constrained', algo='Fisher', data=self._data, response=0, explanatories={1,2,3,4,5,6,7,8,9,10}, slope_constraint=slope_constraint) @classmethod def tearDownClass(cls): """Test multivariate data deletion""" del cls._data
class TestCumulativeLink(unittest.TestCase, AbstractTestVectorLink): _eta = linalg.Vector([0.,1.]) # linear predictors must be strictly ordered for cumulative models ! _mu = linalg.Vector([0.5, -0.5+ math.exp(1)/(1.+math.exp(1))]) _mu_prime = linalg.Matrix([[0.25,-0.25], [0, math.exp(1)/pow(1+math.exp(1), 2)]]) @classmethod def setUpClass(cls): """Test cumulative logistic link construction""" cls._link = glm.OrdinalLink(ratio='cumulative') @classmethod def tearDownClass(cls): """Test cumulative logistic link deletion""" del cls._link
class TestSequentialLink(unittest.TestCase, AbstractTestVectorLink): _eta = linalg.Vector([1.,1.]) norm = 1 + math.exp(1) _mu = linalg.Vector([math.exp(1)/norm, math.exp(1)/pow(norm, 2)]) _mu_prime = linalg.Matrix([[math.exp(1)/pow(norm, 2), -math.exp(2)/pow(norm, 3)], [0, math.exp(1)/pow(norm, 3)]]) @classmethod def setUpClass(cls): """Test Sequential logistic link construction""" cls._link = glm.OrdinalLink(ratio='sequential') @classmethod def tearDownClass(cls): """Test Sequential logistic link deletion""" del cls._link
class TestAdjacentLink(unittest.TestCase, AbstractTestVectorLink): #_places = 5 _eta = linalg.Vector([1.,1.]) norm = 1 + math.exp(1) + math.exp(2) _mu = linalg.Vector([math.exp(2)/norm, math.exp(1)/norm]) _mu_prime = linalg.Matrix([[math.exp(2)*(1+math.exp(1))/norm**2, -math.exp(3)/norm**2], [math.exp(2)/norm**2, math.exp(1)/norm**2]]) @classmethod def setUpClass(cls): """Test adjacent logistic link construction""" cls._link = glm.OrdinalLink(ratio='adjacent') @classmethod def tearDownClass(cls): """Test adjacent logistic link deletion""" del cls._link
def setUpClass(cls): """Test graphical Gaussian distribution construction""" graph = pgm.DirectedGraph(3) graph.add_edge(0, 1) cls._dist = pgm.DirectedGaussianDistribution(graph) cls._dist.predictors[1].delta = linalg.Vector((-1., )) cls._data = cls._dist.simulation(10)
class TestCompleteScalarPredictor(unittest.TestCase, TestPredictor): _alpha = 1. _delta = linalg.Vector([0.5, 2.]) #_x = [1, 1.6] _len = 3 _eta = 4.7 @classmethod def setUpClass(cls): """Test complete scalar predictor construction""" cls.sample_space_init() cls._pred = glm.CompleteScalarPredictor(cls._vector_sample_spaces) def test_predictor(self): """Test complete scalar predictor operator""" self._pred.alpha = self._alpha self._pred.delta = self._delta self.assertEqual(len(self._pred), self._len) self.assertEqual(self._pred(1, 1.6), self._eta) @classmethod def tearDownClass(cls): """Test complete scalar predictor deletion""" del cls._pred
def setUpClass(cls): """Test undirected Gaussian distribution construction""" theta = [] for i in range(cls._K): theta.append([0. if not j in [i, i - 1, i + 1] else 0.5 if j in [i - 1, i + 1] else 1. for j in range(cls._K)]) cls._dist = pgm.UndirectedGaussianDistribution(linalg.Vector([0.] * cls._K), linalg.Matrix(theta)) cls._data = cls._dist.simulation(3 * cls._K + 1)
class TestOrdinalCanonicalLink(unittest.TestCase, AbstractTestVectorLink): #_places = 5 _eta = linalg.Vector([1.,1.]) norm = 1 + math.exp(1) + math.exp(2) _mu = linalg.Vector([math.exp(2)/norm, math.exp(1)/norm]) _mu_prime = linalg.Matrix([[math.exp(2)*(1+math.exp(1))/norm**2, -math.exp(3)/norm**2], [math.exp(2)/norm**2, math.exp(1)/norm**2]]) #_mu_prime = linalg.Matrix([[1,0], [1,1]]) * ( linalg.Matrix(_mu) - _mu * linalg.RowVector(_mu) ) @classmethod def setUpClass(cls): """Test ordinal canonical link construction""" cls._link = glm.OrdinalLink() @classmethod def tearDownClass(cls): """Test ordinal canonical link deletion""" del cls._link
def test_estimation_em(self): """Test mixture estimation using the EM algorithm""" data = self._dist.simulation(100) em = core.mixture_estimation(data, 'em', initializator = core.MixtureDistribution(core.PoissonDistribution(3.), core.PoissonDistribution(5.), pi = linalg.Vector([.5, .5])), default_estimator = core.poisson_estimation('ml'))
def setUpClass(cls): """Test ordinal distribution construction""" cls._dist_unif = core.OrdinalDistribution('C', 'B', 'A') cls._dist = core.OrdinalDistribution('C', 'B', 'A', ordered_pi=linalg.Vector( [2., 1., 3.]))
class AbstractTestVectorLink(object): _places = 5 _eta = linalg.Vector([1.,1.]) _mu = linalg.Vector([math.exp(1)/(1+2*math.exp(1)), math.exp(1)/(1+2*math.exp(1))]) _mu_prime = linalg.Matrix(_mu) - _mu * linalg.RowVector(_mu) def test_evaluate(self): """ Test vector link evaluate """ self.assertEqual(self._link.evaluate(self._mu).round(self._places), self._eta.round(self._places)) def test_inverse(self): """Test vector link inverse""" self.assertEqual(self._link.inverse(self._eta).round(self._places), self._mu.round(self._places)) self.assertEqual(self._link.inverse(self._link.evaluate(self._mu)).round(self._places), self._mu.round(self._places)) def test_inverse_derivative(self): """Test vector link inverse derivative""" self.assertEqual(self._link.inverse_derivative(self._eta).round(self._places), self._mu_prime.round(self._places))
class TestProportionalVectorPredictor(TestCompleteVectorPredictor): _alpha = linalg.Vector([1., 2.]) _delta = linalg.Vector([0.5, 2.]) _len = 4 _eta = linalg.Vector([4.7, 5.7]) @classmethod def setUpClass(cls): """Test proportional vector predictor construction""" cls.sample_space_init() cls._pred = glm.ProportionalVectorPredictor(cls._vector_sample_spaces, 2) @classmethod def tearDownClass(cls): """Test proportional vector predictor deletion""" del cls._pred
class TestCumulativeFLink(unittest.TestCase, AbstractTestVectorLink): _dist = core.CauchyDistribution() _eta = linalg.Vector([0.,1.]) # linear predictors must be strictly ordered for cumulative models ! f0 = _dist.pdf(_eta[0]) f1 = _dist.pdf(_eta[1]) F0 = _dist.cdf(_eta[0]) F1 = _dist.cdf(_eta[1]) _mu = linalg.Vector([F0, F1-F0]) _mu_prime = linalg.Matrix([[f0, -f0], [0, f1]]) @classmethod def setUpClass(cls): """Test cumulative FLink construction""" cls._link = glm.OrdinalLink(ratio='cumulative', distribution=cls._dist) @classmethod def tearDownClass(cls): """Test cumulative FLink deletion""" del cls._link
class TestReferenceRegression(unittest.TestCase, AbstractTestCategoricalRegression): _alpha = linalg.Vector([1., 2.]) _delta = linalg.Matrix([[-1.5, 2.], [-2., 2.5]]) _x = [1, 1.6] _nb_param = 6 _eta = linalg.Vector([2.7, 4.]) _canonical_link = glm.NominalLink(ratio='reference') _norm = 1 + math.exp(_eta[0]) + math.exp(_eta[1]) _mu = linalg.Vector( [math.exp(_eta[0]) / _norm, math.exp(_eta[1]) / _norm, 1 / _norm]) _categories = {'Bb', 'Bc', 'Ba'} _places = 10 @classmethod def setUpClass(cls): """Test reference regression construction""" cls.predictor_init() nss = core.NominalSampleSpace(*cls._categories) cls._model = glm.NominalRegression(nss, cls._pred, cls._canonical_link) def test_get_nb_parameters(self): """Test reference regression get number of parameters""" self.assertEqual(self._model.nb_parameters, self._nb_param) def test_conditional(self): """Test reference regression conditional operator""" response_distribution = self._model(*self._x) self.assertAlmostEqual(response_distribution.pdf('Ba'), self._mu[0], places=self._places) self.assertAlmostEqual(response_distribution.pdf('Bb'), self._mu[1], places=self._places) self.assertAlmostEqual(response_distribution.pdf('Bc'), self._mu[2], places=self._places) @classmethod def tearDownClass(cls): """Test reference regression deletion""" del cls._model
class TestSequentialFLink(unittest.TestCase, AbstractTestVectorLink): _dist = core.GumbelDistribution() _eta = linalg.Vector([0.,1.]) f0 = _dist.pdf(_eta[0]) f1 = _dist.pdf(_eta[1]) F0 = _dist.cdf(_eta[0]) F1 = _dist.cdf(_eta[1]) _mu = linalg.Vector([F0, F1*(1-F0)]) _mu_prime = linalg.Matrix([[f0, -f0*F1], [0, f1*(1-F0)]]) @classmethod def setUpClass(cls): """Test Sequential FLink construction""" cls._link = glm.OrdinalLink(ratio='sequential', distribution=cls._dist) @classmethod def tearDownClass(cls): """Test Sequential FLink deletion""" del cls._link
class TestAdjacentFLink(unittest.TestCase, AbstractTestVectorLink): _dist = core.LaplaceDistribution() _eta = linalg.Vector([1.,1.]) f0 = _dist.pdf(_eta[0]) f1 = _dist.pdf(_eta[1]) F0 = _dist.cdf(_eta[0]) F1 = _dist.cdf(_eta[1]) norm = 1/( 1 + F0/(1-F0) * F1/(1-F1) + F1/(1-F1) ) _mu = linalg.Vector([norm*F0/(1-F0)*F1/(1-F1), norm*F1/(1-F1)]) _mu_prime = linalg.Matrix([[f0/(F0*(1-F0)), 0], [0, f1/(F1*(1-F1))]]) * linalg.Matrix([[1,0], [1,1]]) *( linalg.Matrix(_mu) - _mu * linalg.RowVector(_mu) ) @classmethod def setUpClass(cls): """Test adjacent FLink construction""" cls._link = glm.OrdinalLink(ratio='adjacent', distribution=cls._dist) @classmethod def tearDownClass(cls): """Test adjacent FLink deletion""" del cls._link
class TestSequentialRegression(TestAdjacentRegression): _eta = linalg.Vector([2.7, 4.]) _canonical_link = glm.OrdinalLink(ratio='sequential') _norm = [1 + math.exp(_eta[0]), 1 + math.exp(_eta[1])] _mu = linalg.Vector([ math.exp(_eta[0]) / _norm[0], math.exp(_eta[1]) / (_norm[0] * _norm[1]), 1 / (_norm[0] * _norm[1]) ]) _categories = ['C', 'B', 'A'] @classmethod def setUpClass(cls): """Test cumulative regression construction""" cls.predictor_init() oss = core.OrdinalSampleSpace(*cls._categories) cls._model = glm.OrdinalRegression(oss, cls._pred, cls._canonical_link) @classmethod def tearDownClass(cls): """Test cumulative regression deletion""" del cls._model
class TestReferenceFLink(unittest.TestCase, AbstractTestVectorLink): #_places = 4 _dist = core.NormalDistribution() _eta = linalg.Vector([1.,1.]) f0 = _dist.pdf(_eta[0]) f1 = _dist.pdf(_eta[1]) F0 = _dist.cdf(_eta[0]) F1 = _dist.cdf(_eta[1]) norm = 1/( 1 + F0/(1-F0) + F1/(1-F1) ) _mu = linalg.Vector([norm*F0/(1-F0), norm*F1/(1-F1)]) _mu_prime = linalg.Matrix([[f0/(F0*(1-F0)), 0], [0, f1/(F1*(1-F1))]]) * ( linalg.Matrix(_mu) - _mu * linalg.RowVector(_mu) ) @classmethod def setUpClass(cls): """Test reference FLink construction""" cls._link = glm.NominalLink(ratio='reference', distribution=cls._dist) @classmethod def tearDownClass(cls): """Test reference FLink deletion""" del cls._link
class TestCumulativeRegression(TestAdjacentRegression): _eta = linalg.Vector([2.7, 4.]) _canonical_link = glm.OrdinalLink(ratio='cumulative') _norm = [1 + math.exp(_eta[0]), 1 + math.exp(_eta[1])] _mu = linalg.Vector([ math.exp(_eta[0]) / _norm[0], math.exp(_eta[1]) / _norm[1] - math.exp(_eta[0]) / _norm[0], 1 - math.exp(_eta[1]) / _norm[1] ]) _categories = ['C', 'B', 'A'] @classmethod def setUpClass(cls): """Test cumulative regression construction""" cls.predictor_init() cls._model = glm.OrdinalRegression(cls._categories, cls._pred, cls._canonical_link) @classmethod def tearDownClass(cls): """Test cumulative regression deletion""" del cls._model
class TestCanonicalNominalRegressionEstimation(unittest.TestCase): _alpha = linalg.Vector([-0.591, -1.039]) _delta = linalg.Matrix([[-0.388, 1.128, 1.588], [-0.813, 1.478, 2.917]]) # (Dosbson, 2008) page 155 _loglikelihood = -290.35 @classmethod def setUpClass(cls): """Test multivariate data construction""" cls._data = data.load('cars') cls._data.AirConditioning.sample_space.reference = 'little_important' cls._data.Sex.sample_space.reference = 'women' cls._data.Age.sample_space.reference = '18_23' def test_Fisher(self): """Test Fisher scoring estimation for nominal regression with complete design""" mle = glm.nominal_estimation(data=self._data, response=0, explanatories={1, 2}) self.assertAlmostEqual(mle.loglikelihood, self._loglikelihood, places=2) alpha = mle.estimated.predictor.alpha delta = mle.estimated.predictor.delta for i in range(len(self._alpha)): self.assertAlmostEqual(alpha[i], self._alpha[i], places=3) for j in range(self._delta.nb_cols): self.assertAlmostEqual(delta[i, j], self._delta[i, j], places=3) #mle = glm.nominal_estimation(design='proportional', data=self._data, response = 0, explanatories = {1,2}) @classmethod def tearDownClass(cls): """Test multivariate data deletion""" del cls._data
class TestBinaryRegression(unittest.TestCase, AbstractTestUnivariateRegression): _alpha = 1. _delta = linalg.Vector([-1.5, 2.]) _x = [1, 1.6] _nb_param = 3 _eta = 2.7 _canonical_link = glm.BinaryLink() _pi = math.exp(_eta) / (1 + math.exp(_eta)) _places = 10 @classmethod def setUpClass(cls): """Test binary regression construction""" cls.predictor_init() cls._model = glm.BinaryRegression('A', 'B', cls._pred, cls._canonical_link) def test_get_nb_parameters(self): """Test binary regression get number of parameters""" self.assertEqual(self._model.nb_parameters, self._nb_param) def test_conditional(self): """Test binary regression conditional operator""" response_distribution = self._model(*self._x) self.assertAlmostEqual(response_distribution.pdf('A'), self._pi, places=self._places) self.assertAlmostEqual(response_distribution.pdf('B'), 1 - self._pi, places=self._places) @classmethod def tearDownClass(cls): """Test binary regression deletion""" del cls._model
def setUpClass(cls): """Test multinomial splitting distribution construction""" cls._dist = core.SplittingDistribution(core.BinomialDistribution(5, .5), core.MultinomialSingularDistribution(linalg.Vector([.25, .75])))
def setUpClass(cls): """Test Dirichlet multinomial splitting distribution construction""" cls._dist = core.SplittingDistribution(core.PoissonDistribution(15.), core.DirichletMultinomialSingularDistribution(linalg.Vector([2., 1.])))
class TestHierarchicalRegression(unittest.TestCase, AbstractTestCategoricalRegression): _alpha = linalg.Vector([1., 2.]) _delta = linalg.Matrix([[-1.5, 2.], [-2., 2.5]]) _x = [1, 1.6] _nb_param = 12 _eta = linalg.Vector([2.7, 4.]) _norm_root = [1 + math.exp(_eta[0]), 1 + math.exp(_eta[1])] _mu_root = linalg.Vector([ math.exp(_eta[0]) / _norm_root[0], math.exp(_eta[1]) / _norm_root[1] - math.exp(_eta[0]) / _norm_root[0], 1 - math.exp(_eta[1]) / _norm_root[1] ]) _categories_root = ['C', 'B', 'A'] _norm_B = 1 + math.exp(_eta[0]) + math.exp(_eta[1]) _mu_B = linalg.Vector([ math.exp(_eta[0]) / _norm_B, math.exp(_eta[1]) / _norm_B, 1 / _norm_B ]) _categories_B = {'Ba', 'Bb', 'Bc'} _places = 10 @classmethod def hierarchical_sample_space_init(cls): ordinal_space = core.OrdinalSampleSpace(*cls._categories_root) nominal_space = core.NominalSampleSpace(*cls._categories_B) cls._hss = core.HierarchicalSampleSpace(ordinal_space) cls._hss.partition('B', nominal_space) @classmethod def setUpClass(cls): """Test hierarchical regression construction""" cls.hierarchical_sample_space_init() cls.predictor_init() cls._model = glm.HierarchicalRegression(cls._hss, cls._vector_sample_spaces) @classmethod def test_get_set_regression(self): """Test hierarchical regression get and set regression model""" model_root = self._model.get_regression("") model_root.predictor = self._pred model_root.link = glm.OrdinalLink(ratio='cumulative') self._model.set_regression("", model_root) model_B = self._model.get_regression("B") model_B.predictor = self._pred model_B.link = glm.NominalLink(ratio='reference') self._model.set_regression("B", model_B) def test_get_nb_parameters(self): """Test hierarchical regression get number of parameters""" self.assertEqual( self._model.nb_parameters, self._nb_param ) # Warning after issue #32 it must be equal to 0 and not 12 def test_conditional(self): """Test hierarchical regression conditional operator""" response_distribution = self._model(*self._x) self.assertAlmostEqual(response_distribution.pdf('C'), float(1 / 3), places=self._places) self.assertAlmostEqual(response_distribution.internal_pdf('B'), float(1 / 3), places=self._places) self.assertAlmostEqual(response_distribution.pdf('Ba'), float(1 / 9), places=self._places) self.test_get_set_regression() response_distribution = self._model(*self._x) self.assertAlmostEqual(response_distribution.pdf('C'), self._mu_root[0], places=self._places) self.assertAlmostEqual(response_distribution.internal_pdf('B'), self._mu_root[1], places=self._places) self.assertAlmostEqual(response_distribution.pdf('A'), self._mu_root[2], places=self._places) self.assertAlmostEqual(response_distribution.pdf('Ba'), self._mu_root[1] * self._mu_B[0], places=self._places) self.assertAlmostEqual(response_distribution.pdf('Bb'), self._mu_root[1] * self._mu_B[1], places=self._places) self.assertAlmostEqual(response_distribution.pdf('Bc'), self._mu_root[1] * self._mu_B[2], places=self._places) @classmethod def tearDownClass(cls): """Test hierarchcical regression deletion""" del cls._model