def test_probability_density(self, kde_mock): """Probability_density evaluates with the model.""" # Setup kde_instance = kde_mock.return_value kde_instance.evaluate.return_value = ('probability_density_from_model',) instance = KDEUnivariate() X = np.array([1, 2, 3, 4, 5]) instance.fit(X) # Run result = instance.probability_density(0.5) assert result == 'probability_density_from_model' kde_instance.evaluate.assert_called_once_with(0.5)
def test_probability_density_constant(self, pdf_mock): """If constant_value, probability_density uses the degenerate version.""" # Setup instance = KDEUnivariate() instance.fitted = True instance.constant_value = 3 instance._replace_constant_methods() X = np.array([0, 1, 2, 3, 4, 5]) expected_result = np.array([0, 0, 1, 0, 0]) pdf_mock.return_value = np.array([0, 0, 1, 0, 0]) # Run result = instance.probability_density(X) # Check compare_nested_iterables(result, expected_result) pdf_mock.assert_called_once_with(instance, X)
class TestKDEUnivariate(TestCase): def setup_norm(self): """set up the model to fit standard norm data.""" self.kde = KDEUnivariate() # use 42 as a fixed random seed np.random.seed(42) column = np.random.normal(0, 1, 1000) self.kde.fit(column) def test___init__(self): """On init, model are set to None.""" self.kde = KDEUnivariate() assert self.kde.model is None def test_fit(self): """On fit, kde model is instantiated with intance of gaussian_kde.""" self.kde = KDEUnivariate() data = [1, 2, 3, 4, 5] self.kde.fit(data) self.assertIsInstance(self.kde.model, scipy.stats.gaussian_kde) def test_fit_uniform(self): """On fit, kde model is instantiated with passed data.""" self.kde = KDEUnivariate() data = [1, 2, 3, 4, 5] self.kde.fit(data) assert self.kde.model def test_fit_empty_data(self): """If fitting kde model with empty data it will raise ValueError.""" self.kde = KDEUnivariate() with self.assertRaises(ValueError): self.kde.fit([]) def test_probability_density(self): """probability_density evaluates with the model.""" self.setup_norm() x = self.kde.probability_density(0.5) expected = 0.35206532676429952 self.assertAlmostEquals(x, expected, places=1) def test_cumulative_distribution(self): """cumulative_distribution evaluates with the model.""" self.setup_norm() x = self.kde.cumulative_distribution(0.5) expected = 0.69146246127401312 self.assertAlmostEquals(x, expected, places=1) def test_percent_point(self): """percent_point evaluates with the model.""" self.setup_norm() x = self.kde.percent_point(0.5) expected = 0.0 self.assertAlmostEquals(x, expected, places=1) def test_percent_point_invalid_value(self): """Evaluating an invalid value will raise ValueError.""" self.setup_norm() with self.assertRaises(ValueError): self.kde.percent_point(2) def test_from_dict(self): """From_dict sets the values of a dictionary as attributes of the instance.""" # Setup distribution = KDEUnivariate() parameters = { 'd': 1, 'n': 10, 'dataset': [[ 0.4967141530112327, -0.13826430117118466, 0.6476885381006925, 1.5230298564080254, -0.23415337472333597, -0.23413695694918055, 1.5792128155073915, 0.7674347291529088, -0.4694743859349521, 0.5425600435859647 ]], 'covariance': [[0.2081069604419522]], 'factor': 0.6309573444801932, 'inv_cov': [[4.805221304834407]] } # Run distribution = KDEUnivariate.from_dict(parameters) # Check assert distribution.model.d == 1 assert distribution.model.n == 10 assert distribution.model.covariance == np.array([[0.2081069604419522]]) assert distribution.model.factor == 0.6309573444801932 assert distribution.model.inv_cov == np.array([[4.805221304834407]]) assert (distribution.model.dataset == np.array([[ 0.4967141530112327, -0.13826430117118466, 0.6476885381006925, 1.5230298564080254, -0.23415337472333597, -0.23413695694918055, 1.5792128155073915, 0.7674347291529088, -0.4694743859349521, 0.5425600435859647 ]])).all() def test_to_dict(self): """To_dict returns the defining parameters of a distribution in a dict.""" # Setup distribution = KDEUnivariate() column = np.array([[ 0.4967141530112327, -0.13826430117118466, 0.6476885381006925, 1.5230298564080254, -0.23415337472333597, -0.23413695694918055, 1.5792128155073915, 0.7674347291529088, -0.4694743859349521, 0.5425600435859647 ]]) distribution.fit(column) expected_result = { 'd': 1, 'n': 10, 'dataset': [[ 0.4967141530112327, -0.13826430117118466, 0.6476885381006925, 1.5230298564080254, -0.23415337472333597, -0.23413695694918055, 1.5792128155073915, 0.7674347291529088, -0.4694743859349521, 0.5425600435859647 ]], 'covariance': [[0.20810696044195218]], 'factor': 0.6309573444801932, 'inv_cov': [[4.805221304834407]] } # Run result = distribution.to_dict() # Check compare_nested_dicts(result, expected_result)
class TestKDEUnivariate(TestCase): def setup_norm(self): """set up the model to fit standard norm data.""" self.kde = KDEUnivariate() # use 42 as a fixed random seed np.random.seed(42) column = np.random.normal(0, 1, 1000) self.kde.fit(column) def test___init__(self): """On init, model are set to None.""" # Setup / Run instance = KDEUnivariate() # Check instance.model is None instance.fitted is False instance.constant_value is None @patch('copulas.univariate.kde.scipy.stats.gaussian_kde', autospec=True) def test_fit(self, kde_mock): """On fit, a new instance of gaussian_kde is fitted.""" # Setup instance = KDEUnivariate() X = np.array([1, 2, 3, 4, 5]) kde_mock.return_value = 'mock model' # Run instance.fit(X) # Check assert instance.model == 'mock model' assert instance.fitted is True assert instance.constant_value is None kde_mock.assert_called_once_with(X) def test_fit_constant(self): """If fit data is constant, no gaussian_kde model is created.""" # Setup instance = KDEUnivariate() X = np.array([1, 1, 1, 1, 1]) # Run instance.fit(X) # Check assert instance.model is None assert instance.constant_value == 1 assert instance.fitted is True def test_probability_density(self): """probability_density evaluates with the model.""" self.setup_norm() x = self.kde.probability_density(0.5) expected = 0.35206532676429952 self.assertAlmostEqual(x, expected, places=1) def test_cumulative_distribution(self): """cumulative_distribution evaluates with the model.""" self.setup_norm() x = self.kde.cumulative_distribution(0.5) expected = 0.69146246127401312 self.assertAlmostEqual(x, expected, places=1) def test_percent_point(self): """percent_point evaluates with the model.""" self.setup_norm() x = self.kde.percent_point(0.5) expected = 0.0 self.assertAlmostEqual(x, expected, places=1) def test_percent_point_invalid_value(self): """Evaluating an invalid value will raise ValueError.""" self.setup_norm() with self.assertRaises(ValueError): self.kde.percent_point(2) @patch('copulas.univariate.kde.scipy.stats.gaussian_kde', autospec=True) def test_sample(self, kde_mock): """When fitted, we are able to use the model to get samples.""" # Setup instance = KDEUnivariate() X = np.array([1, 2, 3, 4, 5]) instance.fit(X) model_mock = kde_mock.return_value model_mock.resample.return_value = np.array([0, 1, 0, 1, 0]) expected_result = np.array([0, 1, 0, 1, 0]) # Run result = instance.sample(5) # Check compare_nested_iterables(result, expected_result) assert instance.model == model_mock kde_mock.assert_called_once_with(X) model_mock.resample.assert_called_once_with(5) def test_sample_constant(self): """If constant_value is set, all the sample have the same value.""" # Setup instance = KDEUnivariate() instance.fitted = True instance.constant_value = 3 instance._replace_constant_methods() expected_result = np.array([3, 3, 3, 3, 3]) # Run result = instance.sample(5) # Check compare_nested_iterables(result, expected_result) def test_sample_random_state(self): """If random_state is set, samples will generate the exact same values.""" # Setup instance = KDEUnivariate(random_seed=0) X = np.array([1, 2, 3, 4, 5]) instance.fit(X) expected_result_random_state = np.array( [[5.02156389, 5.45857107, 6.12161148, 4.56801267, 6.14017901]]) # Run result = instance.sample(5) # Check compare_nested_iterables(result, expected_result_random_state) def test_from_dict(self): """From_dict sets the values of a dictionary as attributes of the instance.""" # Setup parameters = { 'fitted': True, 'constant_value': None, 'd': 1, 'n': 10, 'dataset': [[ 0.4967141530112327, -0.13826430117118466, 0.6476885381006925, 1.5230298564080254, -0.23415337472333597, -0.23413695694918055, 1.5792128155073915, 0.7674347291529088, -0.4694743859349521, 0.5425600435859647 ]], 'covariance': [[0.2081069604419522]], 'factor': 0.6309573444801932, 'inv_cov': [[4.805221304834407]] } # Run distribution = KDEUnivariate.from_dict(parameters) # Check assert distribution.model.d == 1 assert distribution.model.n == 10 assert distribution.model.covariance == np.array([[0.2081069604419522] ]) assert distribution.model.factor == 0.6309573444801932 assert distribution.model.inv_cov == np.array([[4.805221304834407]]) assert (distribution.model.dataset == np.array([[ 0.4967141530112327, -0.13826430117118466, 0.6476885381006925, 1.5230298564080254, -0.23415337472333597, -0.23413695694918055, 1.5792128155073915, 0.7674347291529088, -0.4694743859349521, 0.5425600435859647 ]])).all() def test_to_dict(self): """To_dict returns the defining parameters of a distribution in a dict.""" # Setup distribution = KDEUnivariate() column = np.array([[ 0.4967141530112327, -0.13826430117118466, 0.6476885381006925, 1.5230298564080254, -0.23415337472333597, -0.23413695694918055, 1.5792128155073915, 0.7674347291529088, -0.4694743859349521, 0.5425600435859647 ]]) distribution.fit(column) expected_result = { 'type': 'copulas.univariate.kde.KDEUnivariate', 'fitted': True, 'constant_value': None, 'd': 1, 'n': 10, 'dataset': [[ 0.4967141530112327, -0.13826430117118466, 0.6476885381006925, 1.5230298564080254, -0.23415337472333597, -0.23413695694918055, 1.5792128155073915, 0.7674347291529088, -0.4694743859349521, 0.5425600435859647 ]], 'covariance': [[0.20810696044195218]], 'factor': 0.6309573444801932, 'inv_cov': [[4.805221304834407]] } # Run result = distribution.to_dict() # Check compare_nested_dicts(result, expected_result) def test_valid_serialization_unfit_model(self): """For a unfitted model to_dict and from_dict are opposites.""" # Setup instance = KDEUnivariate() # Run result = KDEUnivariate.from_dict(instance.to_dict()) # Check assert instance.to_dict() == result.to_dict() def test_valid_serialization_fit_model(self): """For a fitted model to_dict and from_dict are opposites.""" # Setup instance = KDEUnivariate() X = np.array([1, 2, 3, 4]) instance.fit(X) # Run result = KDEUnivariate.from_dict(instance.to_dict()) # Check assert instance.to_dict() == result.to_dict() @patch('copulas.univariate.base.Univariate._constant_probability_density', autospec=True) def test_probability_density_constant(self, pdf_mock): """If constant_value, probability_density uses the degenerate version.""" # Setup instance = KDEUnivariate() instance.fitted = True instance.constant_value = 3 instance._replace_constant_methods() X = np.array([0, 1, 2, 3, 4, 5]) expected_result = np.array([0, 0, 1, 0, 0]) pdf_mock.return_value = np.array([0, 0, 1, 0, 0]) # Run result = instance.probability_density(X) # Check compare_nested_iterables(result, expected_result) pdf_mock.assert_called_once_with(instance, X) @patch('copulas.univariate.base.Univariate._constant_percent_point', autospec=True) def test_percent_point_constant_raises(self, ppf_mock): """If constant_value, percent_point uses the degenerate version.""" # Setup instance = KDEUnivariate() instance.fitted = True instance.constant_value = 3 instance._replace_constant_methods() X = np.array([0.1, 0.5, 0.75]) expected_result = np.array([3, 3, 3]) ppf_mock.return_value = np.array([3, 3, 3]) # Run result = instance.percent_point(X) # Check compare_nested_iterables(result, expected_result) ppf_mock.assert_called_once_with(instance, X)