def test_distributions_uniform_inertia_fit(): d = UniformDistribution(0, 10) d.fit([0, 5, 3, 5, 7, 3, 4, 5, 2], inertia=0.5) assert_array_equal(d.parameters, [0, 8.5]) assert_array_equal(d.summaries, [inf, -inf, 0])
def test_distributions_uniform_json_serialization(): d = UniformDistribution(0, 10) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "UniformDistribution") assert_array_equal(e.parameters, [0, 10]) assert_array_equal(d.summaries, [inf, -inf, 0])
def test_distributions_uniform_weighted_fit(): d = UniformDistribution(0, 10) d.fit([0, 2, 3, 2, 100], weights=[0, 5, 2, 3, 200]) assert_array_equal(d.parameters, [2, 100]) assert_almost_equal(d.log_probability(50), -4.58496747867) assert_array_equal(d.summaries, [inf, -inf, 0])
def test_distributions_uniform_freeze_fit(): d = UniformDistribution(0, 10) d.freeze() d.fit([0, 1, 1, 2, 3, 2, 1, 2, 2]) assert_array_almost_equal(d.parameters, [0, 10]) assert_array_equal(d.summaries, [inf, -inf, 0])
def test_distributions_uniform_random_sample(): d = UniformDistribution(0, 10) x = numpy.array([2.21993171, 8.70732306, 2.06719155, 9.18610908, 4.88411189]) assert_array_almost_equal(d.sample(5, random_state=5), x) assert_raises(AssertionError, assert_array_almost_equal, d.sample(5), x)
def test_distributions_uniform_probability(): d = UniformDistribution(0, 10) e = UniformDistribution(0., 10.) assert_almost_equal(d.probability(5), 0.0999999999) assert_equal(d.probability(5), e.probability(5)) assert_equal(d.probability(5), d.probability(5.)) assert_almost_equal(d.probability(0), 0.0999999999) assert_equal(d.probability(0), e.probability(0.)) assert_equal(d.probability(-1), 0) assert_equal(d.probability(11), 0)
def test_distributions_uniform_log_probability(): d = UniformDistribution(0, 10) e = UniformDistribution(0., 10.) assert_almost_equal(d.log_probability(5), -2.302585092) assert_equal(d.log_probability(5), e.log_probability(5)) assert_equal(d.log_probability(5), d.log_probability(5.)) assert_almost_equal(d.log_probability(0), -2.302585092) assert_equal(d.log_probability(0), e.log_probability(0.)) assert_equal(d.log_probability(-1), -inf) assert_equal(d.log_probability(11), -inf)
def test_distributions_uniform_freeze_thaw_fit(): d = UniformDistribution(0, 10) d.freeze() d.thaw() d.fit([5, 4, 5, 4, 6, 5, 6, 5, 4, 6, 5, 4]) assert_array_equal(d.parameters, [4, 6])
def test_distributions_uniform_nan_fit(): d = UniformDistribution(5, 2) e = UniformDistribution(5, 2) d.fit([5, 4, nan, 5, 4, nan, 6, 5, 6, nan, nan, 5, 4, 6, nan, 5, 4, nan]) assert_array_equal(d.parameters, [4, 6]) assert_not_equal(d.log_probability(4), e.log_probability(4)) assert_almost_equal(d.log_probability(4), -0.69314718055994529) assert_equal(d.log_probability(18), -inf) assert_equal(d.log_probability(1e8), -inf) assert_array_equal(d.summaries, [inf, -inf, 0])
def test_distributions_uniform_pickle_serialization(): d = UniformDistribution(0, 10) e = pickle.loads(pickle.dumps(d)) assert_equal(e.name, "UniformDistribution") assert_array_equal(e.parameters, [0, 10]) assert_array_equal(d.summaries, [inf, -inf, 0])
def test_distributions_uniform_exclusive_nan_fit(): d = UniformDistribution(0, 10) e = UniformDistribution(0, 10) d.fit([nan, nan, nan, nan, nan]) assert_array_equal(d.parameters, [0, 10]) assert_almost_equal(d.log_probability(4), e.log_probability(4.)) assert_array_equal(d.summaries, [inf, -inf, 0])
def test_distributions_uniform_fit_ooc(): d = UniformDistribution(0, 10) d.summarize([0, 2], weights=[0, 5]) d.summarize([3, 2], weights=[2, 3]) d.summarize([100], weights=[200]) assert_array_equal(d.summaries, [2, 100, 210]) d.from_summaries() assert_array_equal(d.summaries, [inf, -inf, 0]) assert_array_equal(d.parameters, [2, 100])
def test_distributions_independent_random_sample(): d = IndependentComponentsDistribution([NormalDistribution(5, 2), UniformDistribution(0, 10), ExponentialDistribution(7), LogNormalDistribution(0, 0.4)]) x = numpy.array([[5.882455, 2.219932, 0.03586 , 1.193024], [4.33826 , 8.707323, 0.292267, 0.876036], [9.861542, 2.067192, 0.033083, 2.644041]]) assert_array_almost_equal(d.sample(3, random_state=5), x) assert_raises(AssertionError, assert_array_almost_equal, d.sample(5), x)
def test_distributions_uniform_nan_probability(): d = UniformDistribution(0, 10) assert_equal(d.probability(nan), 1) assert_array_almost_equal(d.probability([nan, 5]), [1, 0.0999999999])
def test_distributions_uniform_underflow_probability(): d = UniformDistribution(0, 10) assert_almost_equal(d.probability(1e100), 0.0)
def test_distributions_uniform_nan_from_samples(): d = UniformDistribution.from_samples([5, nan, 2, nan, 4, 6, nan, 8, 3, nan, 6, nan, 8, 3]) assert_array_equal(d.parameters, [2, 8]) assert_array_equal(d.summaries, [inf, -inf, 0])
def test_distributions_uniform_nan_log_probability(): d = UniformDistribution(0, 10) assert_equal(d.log_probability(nan), 0) assert_array_almost_equal(d.log_probability([nan, 5]), [0, -2.302585092])
def test_distributions_uniform_blank(): d = UniformDistribution.blank() assert_equal(d.name, "UniformDistribution") assert_array_equal(d.parameters, [0, 0]) assert_array_equal(d.summaries, [inf, -inf, 0])
def test_uniform(): d = UniformDistribution(0, 10) assert_almost_equal(d.log_probability(2.34), -2.3025850929940455, 8) assert_equal(d.log_probability(2), d.log_probability(8)) assert_equal(d.log_probability(10), d.log_probability(3.4)) assert_equal(d.log_probability(1.7), d.log_probability(9.7)) assert_equal(d.log_probability(10.0001), float("-inf")) assert_equal(d.log_probability(-0.0001), float("-inf")) for i in range(10): data = numpy.random.randn(100) * 100 d.fit(data) assert_equal(d.parameters[0], data.min()) assert_equal(d.parameters[1], data.max()) minimum, maximum = data.min(), data.max() for i in range(100): sample = d.sample() assert_less_equal(minimum, sample) assert_less_equal(sample, maximum) d = UniformDistribution(0, 10) d.fit([-5, 20], inertia=0.5) assert_equal(d.parameters[0], -2.5) assert_equal(d.parameters[1], 15) d.fit([-100, 100], inertia=1.0) assert_equal(d.parameters[0], -2.5) assert_equal(d.parameters[1], 15) d.summarize([0, 50, 2, 24, 28]) d.summarize([-20, 7, 8, 4]) d.from_summaries(inertia=0.75) assert_equal(d.parameters[0], -6.875) assert_equal(d.parameters[1], 23.75) d.summarize([0, 100]) d.summarize([100, 200]) d.from_summaries() assert_equal(d.parameters[0], 0) assert_equal(d.parameters[1], 200) d.freeze() d.fit([0, 1, 6, 7, 8, 3, 4, 5, 2]) assert_equal(d.parameters, [0, 200]) d.thaw() d.fit([0, 1, 6, 7, 8, 3, 4, 5, 2]) assert_equal(d.parameters, [0, 8]) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "UniformDistribution") assert_equal(e.parameters, [0, 8]) f = pickle.loads(pickle.dumps(e)) assert_equal(f.name, "UniformDistribution") assert_equal(f.parameters, [0, 8])
def test_distributions_uniform_underflow_log_probability(): d = UniformDistribution(0, 10) assert_equal(d.log_probability(1e100), float("-inf"))
def test_distributions_uniform_initialization(): d = UniformDistribution(0, 10) assert_equal(d.name, "UniformDistribution") assert_array_equal(d.parameters, [0, 10]) assert_array_equal(d.summaries, [inf, -inf, 0])
def __init__(self, dim , seed=None): # K = 9 theta0=[.5,.5] beta=np.ones(K) Psi = .1*np.diag(np.ones(dim)) #mu0= np.zeros(dim) #lambd=.1, nu=dim+2. rstate = np.random.get_state() np.random.seed(seed) unif_dist = UniformDistribution(0.,1.) self.theta0 = theta0 beta_dist = DirichletDistribution(beta) self.dim = Psi.shape[0] self.dists = [] #same weights for both weights = beta_dist.sample() mus = [] for i,_ in enumerate(theta0): #weights = beta_dist.sample() #print(weights) mix = [] for j,_ in enumerate(weights): if j%3==0: Sigma = invwishart.rvs(df=nu, scale=Psi) elif j%3==1: Sigma = invwishart.rvs(df=nu, scale=.01*Psi) else: Sigma = invwishart.rvs(df=nu, scale=.0001*Psi) if i==0: mu = unif_dist.sample(self.dim) #mu =MultivariateGaussianDistribution(mu0,Sigma/lambd).sample() mus.append(mu) else: mu = mus[j] mix.append( MultivariateGaussianDistribution(mu, Sigma) ) model = GeneralMixtureModel(mix, weights=weights) self.dists.append(model) for d in self.dists: print(d) self.rstate = np.random.get_state() np.random.set_state(rstate)
def test_independent(): d = IndependentComponentsDistribution( [NormalDistribution(5, 2), ExponentialDistribution(2)]) assert_equal(round(d.log_probability((4, 1)), 4), -3.0439) assert_equal(round(d.log_probability((100, 0.001)), 4), -1129.0459) d = IndependentComponentsDistribution( [NormalDistribution(5, 2), ExponentialDistribution(2)], weights=[18., 1.]) assert_equal(round(d.log_probability((4, 1)), 4), -0.1536) assert_equal(round(d.log_probability((100, 0.001)), 4), -1126.1556) d.fit([(5, 1), (5.2, 1.7), (4.7, 1.9), (4.9, 2.4), (4.5, 1.2)]) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.86) assert_equal(round(d.parameters[0][0].parameters[1], 4), 0.2417) assert_equal(round(d.parameters[0][1].parameters[0], 4), 0.6098) d = IndependentComponentsDistribution( [NormalDistribution(5, 2), UniformDistribution(0, 10)]) d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0), (3, 0), (4, 0), (5, 0), (2, 20)], inertia=0.5) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(d.parameters[0][1].parameters[0], -2.5) assert_equal(d.parameters[0][1].parameters[1], 15) d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0), (3, 0), (4, 0), (5, 0), (2, 20)], inertia=0.75) assert_not_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_not_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_not_equal(d.parameters[0][1].parameters[0], -2.5) assert_not_equal(d.parameters[0][1].parameters[1], 15) d = IndependentComponentsDistribution( [NormalDistribution(5, 2), UniformDistribution(0, 10)]) d.summarize([(0, 0), (5, 0), (3, 0)]) d.summarize([(5, -5), (7, 0)]) d.summarize([(3, 0), (4, 0), (5, 0), (2, 20)]) d.from_summaries(inertia=0.5) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(d.parameters[0][1].parameters[0], -2.5) assert_equal(d.parameters[0][1].parameters[1], 15) d.freeze() d.fit([(1, 7), (7, 2), (2, 4), (2, 4), (1, 4)]) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(d.parameters[0][1].parameters[0], -2.5) assert_equal(d.parameters[0][1].parameters[1], 15) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "IndependentComponentsDistribution") assert_equal(round(e.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(e.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(e.parameters[0][1].parameters[0], -2.5) assert_equal(e.parameters[0][1].parameters[1], 15) f = pickle.loads(pickle.dumps(e)) assert_equal(e.name, "IndependentComponentsDistribution") assert_equal(round(f.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(f.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(f.parameters[0][1].parameters[0], -2.5) assert_equal(f.parameters[0][1].parameters[1], 15)
def test_independent(): d = IndependentComponentsDistribution( [NormalDistribution(5, 2), ExponentialDistribution(2)]) assert_equal(round(d.log_probability((4, 1)), 4), -3.0439) assert_equal(round(d.log_probability((100, 0.001)), 4), -1129.0459) d = IndependentComponentsDistribution( [NormalDistribution(5, 2), ExponentialDistribution(2)], weights=[18., 1.]) assert_equal(round(d.log_probability((4, 1)), 4), -32.5744) assert_equal(round(d.log_probability((100, 0.001)), 4), -20334.5764) d.fit([(5, 1), (5.2, 1.7), (4.7, 1.9), (4.9, 2.4), (4.5, 1.2)]) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.86) assert_equal(round(d.parameters[0][0].parameters[1], 4), 0.2417) assert_equal(round(d.parameters[0][1].parameters[0], 4), 0.6098) d = IndependentComponentsDistribution( [NormalDistribution(5, 2), UniformDistribution(0, 10)]) d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0), (3, 0), (4, 0), (5, 0), (2, 20)], inertia=0.5) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(d.parameters[0][1].parameters[0], -2.5) assert_equal(d.parameters[0][1].parameters[1], 15) d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0), (3, 0), (4, 0), (5, 0), (2, 20)], inertia=0.75) assert_not_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_not_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_not_equal(d.parameters[0][1].parameters[0], -2.5) assert_not_equal(d.parameters[0][1].parameters[1], 15) d = IndependentComponentsDistribution( [NormalDistribution(5, 2), UniformDistribution(0, 10)]) d.summarize([(0, 0), (5, 0), (3, 0)]) d.summarize([(5, -5), (7, 0)]) d.summarize([(3, 0), (4, 0), (5, 0), (2, 20)]) d.from_summaries(inertia=0.5) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(d.parameters[0][1].parameters[0], -2.5) assert_equal(d.parameters[0][1].parameters[1], 15) d.freeze() d.fit([(1, 7), (7, 2), (2, 4), (2, 4), (1, 4)]) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(d.parameters[0][1].parameters[0], -2.5) assert_equal(d.parameters[0][1].parameters[1], 15) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "IndependentComponentsDistribution") assert_equal(round(e.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(e.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(e.parameters[0][1].parameters[0], -2.5) assert_equal(e.parameters[0][1].parameters[1], 15) f = pickle.loads(pickle.dumps(e)) assert_equal(e.name, "IndependentComponentsDistribution") assert_equal(round(f.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(f.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(f.parameters[0][1].parameters[0], -2.5) assert_equal(f.parameters[0][1].parameters[1], 15) X = numpy.array([[0.5, 0.2, 0.7], [0.3, 0.1, 0.9], [0.4, 0.3, 0.8], [0.3, 0.3, 0.9], [0.3, 0.2, 0.6], [0.5, 0.2, 0.8]]) d = IndependentComponentsDistribution.from_samples( X, distributions=NormalDistribution) assert_almost_equal(d.parameters[0][0].parameters[0], 0.38333, 4) assert_almost_equal(d.parameters[0][0].parameters[1], 0.08975, 4) assert_almost_equal(d.parameters[0][1].parameters[0], 0.21666, 4) assert_almost_equal(d.parameters[0][1].parameters[1], 0.06872, 4) assert_almost_equal(d.parameters[0][2].parameters[0], 0.78333, 4) assert_almost_equal(d.parameters[0][2].parameters[1], 0.10672, 4) d = IndependentComponentsDistribution.from_samples( X, distributions=ExponentialDistribution) assert_almost_equal(d.parameters[0][0].parameters[0], 2.6087, 4) assert_almost_equal(d.parameters[0][1].parameters[0], 4.6154, 4) assert_almost_equal(d.parameters[0][2].parameters[0], 1.2766, 4) d = IndependentComponentsDistribution.from_samples(X, distributions=[ NormalDistribution, NormalDistribution, NormalDistribution ]) assert_almost_equal(d.parameters[0][0].parameters[0], 0.38333, 4) assert_almost_equal(d.parameters[0][0].parameters[1], 0.08975, 4) assert_almost_equal(d.parameters[0][1].parameters[0], 0.21666, 4) assert_almost_equal(d.parameters[0][1].parameters[1], 0.06872, 4) assert_almost_equal(d.parameters[0][2].parameters[0], 0.78333, 4) assert_almost_equal(d.parameters[0][2].parameters[1], 0.10672, 4) d = IndependentComponentsDistribution.from_samples( X, distributions=[ NormalDistribution, LogNormalDistribution, ExponentialDistribution ]) assert_almost_equal(d.parameters[0][0].parameters[0], 0.38333, 4) assert_almost_equal(d.parameters[0][0].parameters[1], 0.08975, 4) assert_almost_equal(d.parameters[0][1].parameters[0], -1.5898, 4) assert_almost_equal(d.parameters[0][1].parameters[1], 0.36673, 4) assert_almost_equal(d.parameters[0][2].parameters[0], 1.27660, 4)
from pomegranate import ( NaiveBayes, NormalDistribution, UniformDistribution, ExponentialDistribution, GeneralMixtureModel, MultivariateGaussianDistribution, BernoulliDistribution, ) import pandas as pd import numpy as np X = pd.DataFrame({"A": [1, 0, 1, 0, 1], "B": [1, 1, 1, 1, 0]}) x = BernoulliDistribution(0.4) vals = [] [vals.append(x.sample()) for i in range(1000)] model = NaiveBayes([ NormalDistribution(5, 2), UniformDistribution(0, 10), ExponentialDistribution(1.0) ]) model.predict(np.array([[10]])) model = GeneralMixtureModel.from_samples(MultivariateGaussianDistribution, n_components=3, X=X)