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_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_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_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_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_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_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_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_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_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_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_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_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_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_underflow_probability(): d = UniformDistribution(0, 10) assert_almost_equal(d.probability(1e100), 0.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_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_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_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_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_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_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_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_underflow_log_probability():
d = UniformDistribution(0, 10)
assert_equal(d.log_probability(1e100), float("-inf"))
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_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_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_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_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)
