switching to high quality piper tts and added label translations
This commit is contained in:
Matthias Hinrichs
@@ -0,0 +1,105 @@
|
||||
from functools import singledispatch
|
||||
|
||||
from sympy.external import import_module
|
||||
from sympy.stats.crv_types import BetaDistribution, ChiSquaredDistribution, ExponentialDistribution, GammaDistribution, \
|
||||
LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, FDistributionDistribution, GumbelDistribution, LaplaceDistribution, \
|
||||
LogisticDistribution, RayleighDistribution, TriangularDistribution
|
||||
from sympy.stats.drv_types import GeometricDistribution, PoissonDistribution, ZetaDistribution
|
||||
from sympy.stats.frv_types import BinomialDistribution, HypergeometricDistribution
|
||||
|
||||
|
||||
numpy = import_module('numpy')
|
||||
|
||||
|
||||
@singledispatch
|
||||
def do_sample_numpy(dist, size, rand_state):
|
||||
return None
|
||||
|
||||
|
||||
# CRV:
|
||||
|
||||
@do_sample_numpy.register(BetaDistribution)
|
||||
def _(dist: BetaDistribution, size, rand_state):
|
||||
return rand_state.beta(a=float(dist.alpha), b=float(dist.beta), size=size)
|
||||
|
||||
|
||||
@do_sample_numpy.register(ChiSquaredDistribution)
|
||||
def _(dist: ChiSquaredDistribution, size, rand_state):
|
||||
return rand_state.chisquare(df=float(dist.k), size=size)
|
||||
|
||||
|
||||
@do_sample_numpy.register(ExponentialDistribution)
|
||||
def _(dist: ExponentialDistribution, size, rand_state):
|
||||
return rand_state.exponential(1 / float(dist.rate), size=size)
|
||||
|
||||
@do_sample_numpy.register(FDistributionDistribution)
|
||||
def _(dist: FDistributionDistribution, size, rand_state):
|
||||
return rand_state.f(dfnum = float(dist.d1), dfden = float(dist.d2), size=size)
|
||||
|
||||
@do_sample_numpy.register(GammaDistribution)
|
||||
def _(dist: GammaDistribution, size, rand_state):
|
||||
return rand_state.gamma(shape = float(dist.k), scale = float(dist.theta), size=size)
|
||||
|
||||
@do_sample_numpy.register(GumbelDistribution)
|
||||
def _(dist: GumbelDistribution, size, rand_state):
|
||||
return rand_state.gumbel(loc = float(dist.mu), scale = float(dist.beta), size=size)
|
||||
|
||||
@do_sample_numpy.register(LaplaceDistribution)
|
||||
def _(dist: LaplaceDistribution, size, rand_state):
|
||||
return rand_state.laplace(loc = float(dist.mu), scale = float(dist.b), size=size)
|
||||
|
||||
@do_sample_numpy.register(LogisticDistribution)
|
||||
def _(dist: LogisticDistribution, size, rand_state):
|
||||
return rand_state.logistic(loc = float(dist.mu), scale = float(dist.s), size=size)
|
||||
|
||||
@do_sample_numpy.register(LogNormalDistribution)
|
||||
def _(dist: LogNormalDistribution, size, rand_state):
|
||||
return rand_state.lognormal(mean = float(dist.mean), sigma = float(dist.std), size=size)
|
||||
|
||||
@do_sample_numpy.register(NormalDistribution)
|
||||
def _(dist: NormalDistribution, size, rand_state):
|
||||
return rand_state.normal(loc = float(dist.mean), scale = float(dist.std), size=size)
|
||||
|
||||
@do_sample_numpy.register(RayleighDistribution)
|
||||
def _(dist: RayleighDistribution, size, rand_state):
|
||||
return rand_state.rayleigh(scale = float(dist.sigma), size=size)
|
||||
|
||||
@do_sample_numpy.register(ParetoDistribution)
|
||||
def _(dist: ParetoDistribution, size, rand_state):
|
||||
return (numpy.random.pareto(a=float(dist.alpha), size=size) + 1) * float(dist.xm)
|
||||
|
||||
@do_sample_numpy.register(TriangularDistribution)
|
||||
def _(dist: TriangularDistribution, size, rand_state):
|
||||
return rand_state.triangular(left = float(dist.a), mode = float(dist.b), right = float(dist.c), size=size)
|
||||
|
||||
@do_sample_numpy.register(UniformDistribution)
|
||||
def _(dist: UniformDistribution, size, rand_state):
|
||||
return rand_state.uniform(low=float(dist.left), high=float(dist.right), size=size)
|
||||
|
||||
|
||||
# DRV:
|
||||
|
||||
@do_sample_numpy.register(GeometricDistribution)
|
||||
def _(dist: GeometricDistribution, size, rand_state):
|
||||
return rand_state.geometric(p=float(dist.p), size=size)
|
||||
|
||||
|
||||
@do_sample_numpy.register(PoissonDistribution)
|
||||
def _(dist: PoissonDistribution, size, rand_state):
|
||||
return rand_state.poisson(lam=float(dist.lamda), size=size)
|
||||
|
||||
|
||||
@do_sample_numpy.register(ZetaDistribution)
|
||||
def _(dist: ZetaDistribution, size, rand_state):
|
||||
return rand_state.zipf(a=float(dist.s), size=size)
|
||||
|
||||
|
||||
# FRV:
|
||||
|
||||
@do_sample_numpy.register(BinomialDistribution)
|
||||
def _(dist: BinomialDistribution, size, rand_state):
|
||||
return rand_state.binomial(n=int(dist.n), p=float(dist.p), size=size)
|
||||
|
||||
@do_sample_numpy.register(HypergeometricDistribution)
|
||||
def _(dist: HypergeometricDistribution, size, rand_state):
|
||||
return rand_state.hypergeometric(ngood = int(dist.N), nbad = int(dist.m), nsample = int(dist.n), size=size)
|
||||
@@ -0,0 +1,99 @@
|
||||
from functools import singledispatch
|
||||
from sympy.external import import_module
|
||||
from sympy.stats.crv_types import BetaDistribution, CauchyDistribution, ChiSquaredDistribution, ExponentialDistribution, \
|
||||
GammaDistribution, LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, \
|
||||
GaussianInverseDistribution
|
||||
from sympy.stats.drv_types import PoissonDistribution, GeometricDistribution, NegativeBinomialDistribution
|
||||
from sympy.stats.frv_types import BinomialDistribution, BernoulliDistribution
|
||||
|
||||
|
||||
try:
|
||||
import pymc
|
||||
except ImportError:
|
||||
pymc = import_module('pymc3')
|
||||
|
||||
@singledispatch
|
||||
def do_sample_pymc(dist):
|
||||
return None
|
||||
|
||||
|
||||
# CRV:
|
||||
|
||||
@do_sample_pymc.register(BetaDistribution)
|
||||
def _(dist: BetaDistribution):
|
||||
return pymc.Beta('X', alpha=float(dist.alpha), beta=float(dist.beta))
|
||||
|
||||
|
||||
@do_sample_pymc.register(CauchyDistribution)
|
||||
def _(dist: CauchyDistribution):
|
||||
return pymc.Cauchy('X', alpha=float(dist.x0), beta=float(dist.gamma))
|
||||
|
||||
|
||||
@do_sample_pymc.register(ChiSquaredDistribution)
|
||||
def _(dist: ChiSquaredDistribution):
|
||||
return pymc.ChiSquared('X', nu=float(dist.k))
|
||||
|
||||
|
||||
@do_sample_pymc.register(ExponentialDistribution)
|
||||
def _(dist: ExponentialDistribution):
|
||||
return pymc.Exponential('X', lam=float(dist.rate))
|
||||
|
||||
|
||||
@do_sample_pymc.register(GammaDistribution)
|
||||
def _(dist: GammaDistribution):
|
||||
return pymc.Gamma('X', alpha=float(dist.k), beta=1 / float(dist.theta))
|
||||
|
||||
|
||||
@do_sample_pymc.register(LogNormalDistribution)
|
||||
def _(dist: LogNormalDistribution):
|
||||
return pymc.Lognormal('X', mu=float(dist.mean), sigma=float(dist.std))
|
||||
|
||||
|
||||
@do_sample_pymc.register(NormalDistribution)
|
||||
def _(dist: NormalDistribution):
|
||||
return pymc.Normal('X', float(dist.mean), float(dist.std))
|
||||
|
||||
|
||||
@do_sample_pymc.register(GaussianInverseDistribution)
|
||||
def _(dist: GaussianInverseDistribution):
|
||||
return pymc.Wald('X', mu=float(dist.mean), lam=float(dist.shape))
|
||||
|
||||
|
||||
@do_sample_pymc.register(ParetoDistribution)
|
||||
def _(dist: ParetoDistribution):
|
||||
return pymc.Pareto('X', alpha=float(dist.alpha), m=float(dist.xm))
|
||||
|
||||
|
||||
@do_sample_pymc.register(UniformDistribution)
|
||||
def _(dist: UniformDistribution):
|
||||
return pymc.Uniform('X', lower=float(dist.left), upper=float(dist.right))
|
||||
|
||||
|
||||
# DRV:
|
||||
|
||||
@do_sample_pymc.register(GeometricDistribution)
|
||||
def _(dist: GeometricDistribution):
|
||||
return pymc.Geometric('X', p=float(dist.p))
|
||||
|
||||
|
||||
@do_sample_pymc.register(NegativeBinomialDistribution)
|
||||
def _(dist: NegativeBinomialDistribution):
|
||||
return pymc.NegativeBinomial('X', mu=float((dist.p * dist.r) / (1 - dist.p)),
|
||||
alpha=float(dist.r))
|
||||
|
||||
|
||||
@do_sample_pymc.register(PoissonDistribution)
|
||||
def _(dist: PoissonDistribution):
|
||||
return pymc.Poisson('X', mu=float(dist.lamda))
|
||||
|
||||
|
||||
# FRV:
|
||||
|
||||
@do_sample_pymc.register(BernoulliDistribution)
|
||||
def _(dist: BernoulliDistribution):
|
||||
return pymc.Bernoulli('X', p=float(dist.p))
|
||||
|
||||
|
||||
@do_sample_pymc.register(BinomialDistribution)
|
||||
def _(dist: BinomialDistribution):
|
||||
return pymc.Binomial('X', n=int(dist.n), p=float(dist.p))
|
||||
@@ -0,0 +1,167 @@
|
||||
from functools import singledispatch
|
||||
|
||||
from sympy.core.symbol import Dummy
|
||||
from sympy.functions.elementary.exponential import exp
|
||||
from sympy.utilities.lambdify import lambdify
|
||||
from sympy.external import import_module
|
||||
from sympy.stats import DiscreteDistributionHandmade
|
||||
from sympy.stats.crv import SingleContinuousDistribution
|
||||
from sympy.stats.crv_types import ChiSquaredDistribution, ExponentialDistribution, GammaDistribution, \
|
||||
LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, BetaDistribution, \
|
||||
StudentTDistribution, CauchyDistribution
|
||||
from sympy.stats.drv_types import GeometricDistribution, LogarithmicDistribution, NegativeBinomialDistribution, \
|
||||
PoissonDistribution, SkellamDistribution, YuleSimonDistribution, ZetaDistribution
|
||||
from sympy.stats.frv import SingleFiniteDistribution
|
||||
|
||||
|
||||
scipy = import_module("scipy", import_kwargs={'fromlist':['stats']})
|
||||
|
||||
|
||||
@singledispatch
|
||||
def do_sample_scipy(dist, size, seed):
|
||||
return None
|
||||
|
||||
|
||||
# CRV
|
||||
|
||||
@do_sample_scipy.register(SingleContinuousDistribution)
|
||||
def _(dist: SingleContinuousDistribution, size, seed):
|
||||
# if we don't need to make a handmade pdf, we won't
|
||||
import scipy.stats
|
||||
|
||||
z = Dummy('z')
|
||||
handmade_pdf = lambdify(z, dist.pdf(z), ['numpy', 'scipy'])
|
||||
|
||||
class scipy_pdf(scipy.stats.rv_continuous):
|
||||
def _pdf(dist, x):
|
||||
return handmade_pdf(x)
|
||||
|
||||
scipy_rv = scipy_pdf(a=float(dist.set._inf),
|
||||
b=float(dist.set._sup), name='scipy_pdf')
|
||||
return scipy_rv.rvs(size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(ChiSquaredDistribution)
|
||||
def _(dist: ChiSquaredDistribution, size, seed):
|
||||
# same parametrisation
|
||||
return scipy.stats.chi2.rvs(df=float(dist.k), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(ExponentialDistribution)
|
||||
def _(dist: ExponentialDistribution, size, seed):
|
||||
# https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.expon.html#scipy.stats.expon
|
||||
return scipy.stats.expon.rvs(scale=1 / float(dist.rate), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(GammaDistribution)
|
||||
def _(dist: GammaDistribution, size, seed):
|
||||
# https://stackoverflow.com/questions/42150965/how-to-plot-gamma-distribution-with-alpha-and-beta-parameters-in-python
|
||||
return scipy.stats.gamma.rvs(a=float(dist.k), scale=float(dist.theta), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(LogNormalDistribution)
|
||||
def _(dist: LogNormalDistribution, size, seed):
|
||||
# https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.lognorm.html
|
||||
return scipy.stats.lognorm.rvs(scale=float(exp(dist.mean)), s=float(dist.std), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(NormalDistribution)
|
||||
def _(dist: NormalDistribution, size, seed):
|
||||
return scipy.stats.norm.rvs(loc=float(dist.mean), scale=float(dist.std), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(ParetoDistribution)
|
||||
def _(dist: ParetoDistribution, size, seed):
|
||||
# https://stackoverflow.com/questions/42260519/defining-pareto-distribution-in-python-scipy
|
||||
return scipy.stats.pareto.rvs(b=float(dist.alpha), scale=float(dist.xm), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(StudentTDistribution)
|
||||
def _(dist: StudentTDistribution, size, seed):
|
||||
return scipy.stats.t.rvs(df=float(dist.nu), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(UniformDistribution)
|
||||
def _(dist: UniformDistribution, size, seed):
|
||||
# https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.uniform.html
|
||||
return scipy.stats.uniform.rvs(loc=float(dist.left), scale=float(dist.right - dist.left), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(BetaDistribution)
|
||||
def _(dist: BetaDistribution, size, seed):
|
||||
# same parametrisation
|
||||
return scipy.stats.beta.rvs(a=float(dist.alpha), b=float(dist.beta), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(CauchyDistribution)
|
||||
def _(dist: CauchyDistribution, size, seed):
|
||||
return scipy.stats.cauchy.rvs(loc=float(dist.x0), scale=float(dist.gamma), size=size, random_state=seed)
|
||||
|
||||
|
||||
# DRV:
|
||||
|
||||
@do_sample_scipy.register(DiscreteDistributionHandmade)
|
||||
def _(dist: DiscreteDistributionHandmade, size, seed):
|
||||
from scipy.stats import rv_discrete
|
||||
|
||||
z = Dummy('z')
|
||||
handmade_pmf = lambdify(z, dist.pdf(z), ['numpy', 'scipy'])
|
||||
|
||||
class scipy_pmf(rv_discrete):
|
||||
def _pmf(dist, x):
|
||||
return handmade_pmf(x)
|
||||
|
||||
scipy_rv = scipy_pmf(a=float(dist.set._inf), b=float(dist.set._sup),
|
||||
name='scipy_pmf')
|
||||
return scipy_rv.rvs(size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(GeometricDistribution)
|
||||
def _(dist: GeometricDistribution, size, seed):
|
||||
return scipy.stats.geom.rvs(p=float(dist.p), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(LogarithmicDistribution)
|
||||
def _(dist: LogarithmicDistribution, size, seed):
|
||||
return scipy.stats.logser.rvs(p=float(dist.p), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(NegativeBinomialDistribution)
|
||||
def _(dist: NegativeBinomialDistribution, size, seed):
|
||||
return scipy.stats.nbinom.rvs(n=float(dist.r), p=float(dist.p), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(PoissonDistribution)
|
||||
def _(dist: PoissonDistribution, size, seed):
|
||||
return scipy.stats.poisson.rvs(mu=float(dist.lamda), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(SkellamDistribution)
|
||||
def _(dist: SkellamDistribution, size, seed):
|
||||
return scipy.stats.skellam.rvs(mu1=float(dist.mu1), mu2=float(dist.mu2), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(YuleSimonDistribution)
|
||||
def _(dist: YuleSimonDistribution, size, seed):
|
||||
return scipy.stats.yulesimon.rvs(alpha=float(dist.rho), size=size, random_state=seed)
|
||||
|
||||
|
||||
@do_sample_scipy.register(ZetaDistribution)
|
||||
def _(dist: ZetaDistribution, size, seed):
|
||||
return scipy.stats.zipf.rvs(a=float(dist.s), size=size, random_state=seed)
|
||||
|
||||
|
||||
# FRV:
|
||||
|
||||
@do_sample_scipy.register(SingleFiniteDistribution)
|
||||
def _(dist: SingleFiniteDistribution, size, seed):
|
||||
# scipy can handle with custom distributions
|
||||
|
||||
from scipy.stats import rv_discrete
|
||||
density_ = dist.dict
|
||||
x, y = [], []
|
||||
for k, v in density_.items():
|
||||
x.append(int(k))
|
||||
y.append(float(v))
|
||||
scipy_rv = rv_discrete(name='scipy_rv', values=(x, y))
|
||||
return scipy_rv.rvs(size=size, random_state=seed)
|
||||
+181
@@ -0,0 +1,181 @@
|
||||
from sympy.core.numbers import oo
|
||||
from sympy.core.symbol import Symbol
|
||||
from sympy.functions.elementary.exponential import exp
|
||||
from sympy.sets.sets import Interval
|
||||
from sympy.external import import_module
|
||||
from sympy.stats import Beta, Chi, Normal, Gamma, Exponential, LogNormal, Pareto, ChiSquared, Uniform, sample, \
|
||||
BetaPrime, Cauchy, GammaInverse, GaussianInverse, StudentT, Weibull, density, ContinuousRV, FDistribution, \
|
||||
Gumbel, Laplace, Logistic, Rayleigh, Triangular
|
||||
from sympy.testing.pytest import skip, raises
|
||||
|
||||
|
||||
def test_sample_numpy():
|
||||
distribs_numpy = [
|
||||
Beta("B", 1, 1),
|
||||
Normal("N", 0, 1),
|
||||
Gamma("G", 2, 7),
|
||||
Exponential("E", 2),
|
||||
LogNormal("LN", 0, 1),
|
||||
Pareto("P", 1, 1),
|
||||
ChiSquared("CS", 2),
|
||||
Uniform("U", 0, 1),
|
||||
FDistribution("FD", 1, 2),
|
||||
Gumbel("GB", 1, 2),
|
||||
Laplace("L", 1, 2),
|
||||
Logistic("LO", 1, 2),
|
||||
Rayleigh("R", 1),
|
||||
Triangular("T", 1, 2, 2),
|
||||
]
|
||||
size = 3
|
||||
numpy = import_module('numpy')
|
||||
if not numpy:
|
||||
skip('Numpy is not installed. Abort tests for _sample_numpy.')
|
||||
else:
|
||||
for X in distribs_numpy:
|
||||
samps = sample(X, size=size, library='numpy')
|
||||
for sam in samps:
|
||||
assert sam in X.pspace.domain.set
|
||||
raises(NotImplementedError,
|
||||
lambda: sample(Chi("C", 1), library='numpy'))
|
||||
raises(NotImplementedError,
|
||||
lambda: Chi("C", 1).pspace.distribution.sample(library='tensorflow'))
|
||||
|
||||
|
||||
def test_sample_scipy():
|
||||
distribs_scipy = [
|
||||
Beta("B", 1, 1),
|
||||
BetaPrime("BP", 1, 1),
|
||||
Cauchy("C", 1, 1),
|
||||
Chi("C", 1),
|
||||
Normal("N", 0, 1),
|
||||
Gamma("G", 2, 7),
|
||||
GammaInverse("GI", 1, 1),
|
||||
GaussianInverse("GUI", 1, 1),
|
||||
Exponential("E", 2),
|
||||
LogNormal("LN", 0, 1),
|
||||
Pareto("P", 1, 1),
|
||||
StudentT("S", 2),
|
||||
ChiSquared("CS", 2),
|
||||
Uniform("U", 0, 1)
|
||||
]
|
||||
size = 3
|
||||
scipy = import_module('scipy')
|
||||
if not scipy:
|
||||
skip('Scipy is not installed. Abort tests for _sample_scipy.')
|
||||
else:
|
||||
for X in distribs_scipy:
|
||||
samps = sample(X, size=size, library='scipy')
|
||||
samps2 = sample(X, size=(2, 2), library='scipy')
|
||||
for sam in samps:
|
||||
assert sam in X.pspace.domain.set
|
||||
for i in range(2):
|
||||
for j in range(2):
|
||||
assert samps2[i][j] in X.pspace.domain.set
|
||||
|
||||
|
||||
def test_sample_pymc():
|
||||
distribs_pymc = [
|
||||
Beta("B", 1, 1),
|
||||
Cauchy("C", 1, 1),
|
||||
Normal("N", 0, 1),
|
||||
Gamma("G", 2, 7),
|
||||
GaussianInverse("GI", 1, 1),
|
||||
Exponential("E", 2),
|
||||
LogNormal("LN", 0, 1),
|
||||
Pareto("P", 1, 1),
|
||||
ChiSquared("CS", 2),
|
||||
Uniform("U", 0, 1)
|
||||
]
|
||||
size = 3
|
||||
pymc = import_module('pymc')
|
||||
if not pymc:
|
||||
skip('PyMC is not installed. Abort tests for _sample_pymc.')
|
||||
else:
|
||||
for X in distribs_pymc:
|
||||
samps = sample(X, size=size, library='pymc')
|
||||
for sam in samps:
|
||||
assert sam in X.pspace.domain.set
|
||||
raises(NotImplementedError,
|
||||
lambda: sample(Chi("C", 1), library='pymc'))
|
||||
|
||||
|
||||
def test_sampling_gamma_inverse():
|
||||
scipy = import_module('scipy')
|
||||
if not scipy:
|
||||
skip('Scipy not installed. Abort tests for sampling of gamma inverse.')
|
||||
X = GammaInverse("x", 1, 1)
|
||||
assert sample(X) in X.pspace.domain.set
|
||||
|
||||
|
||||
def test_lognormal_sampling():
|
||||
# Right now, only density function and sampling works
|
||||
scipy = import_module('scipy')
|
||||
if not scipy:
|
||||
skip('Scipy is not installed. Abort tests')
|
||||
for i in range(3):
|
||||
X = LogNormal('x', i, 1)
|
||||
assert sample(X) in X.pspace.domain.set
|
||||
|
||||
size = 5
|
||||
samps = sample(X, size=size)
|
||||
for samp in samps:
|
||||
assert samp in X.pspace.domain.set
|
||||
|
||||
|
||||
def test_sampling_gaussian_inverse():
|
||||
scipy = import_module('scipy')
|
||||
if not scipy:
|
||||
skip('Scipy not installed. Abort tests for sampling of Gaussian inverse.')
|
||||
X = GaussianInverse("x", 1, 1)
|
||||
assert sample(X, library='scipy') in X.pspace.domain.set
|
||||
|
||||
|
||||
def test_prefab_sampling():
|
||||
scipy = import_module('scipy')
|
||||
if not scipy:
|
||||
skip('Scipy is not installed. Abort tests')
|
||||
N = Normal('X', 0, 1)
|
||||
L = LogNormal('L', 0, 1)
|
||||
E = Exponential('Ex', 1)
|
||||
P = Pareto('P', 1, 3)
|
||||
W = Weibull('W', 1, 1)
|
||||
U = Uniform('U', 0, 1)
|
||||
B = Beta('B', 2, 5)
|
||||
G = Gamma('G', 1, 3)
|
||||
|
||||
variables = [N, L, E, P, W, U, B, G]
|
||||
niter = 10
|
||||
size = 5
|
||||
for var in variables:
|
||||
for _ in range(niter):
|
||||
assert sample(var) in var.pspace.domain.set
|
||||
samps = sample(var, size=size)
|
||||
for samp in samps:
|
||||
assert samp in var.pspace.domain.set
|
||||
|
||||
|
||||
def test_sample_continuous():
|
||||
z = Symbol('z')
|
||||
Z = ContinuousRV(z, exp(-z), set=Interval(0, oo))
|
||||
assert density(Z)(-1) == 0
|
||||
|
||||
scipy = import_module('scipy')
|
||||
if not scipy:
|
||||
skip('Scipy is not installed. Abort tests')
|
||||
assert sample(Z) in Z.pspace.domain.set
|
||||
sym, val = list(Z.pspace.sample().items())[0]
|
||||
assert sym == Z and val in Interval(0, oo)
|
||||
|
||||
libraries = ['scipy', 'numpy', 'pymc']
|
||||
for lib in libraries:
|
||||
try:
|
||||
imported_lib = import_module(lib)
|
||||
if imported_lib:
|
||||
s0, s1, s2 = [], [], []
|
||||
s0 = sample(Z, size=10, library=lib, seed=0)
|
||||
s1 = sample(Z, size=10, library=lib, seed=0)
|
||||
s2 = sample(Z, size=10, library=lib, seed=1)
|
||||
assert all(s0 == s1)
|
||||
assert all(s1 != s2)
|
||||
except NotImplementedError:
|
||||
continue
|
||||
+109
@@ -0,0 +1,109 @@
|
||||
from sympy.core.singleton import S
|
||||
from sympy.core.symbol import Symbol
|
||||
from sympy.external import import_module
|
||||
from sympy.stats import (
|
||||
Geometric,
|
||||
Poisson,
|
||||
Zeta,
|
||||
sample,
|
||||
Skellam,
|
||||
Logarithmic,
|
||||
NegativeBinomial,
|
||||
YuleSimon,
|
||||
DiscreteRV,
|
||||
)
|
||||
from sympy.testing.pytest import skip, raises, slow
|
||||
|
||||
|
||||
def test_sample_numpy():
|
||||
distribs_numpy = [
|
||||
Geometric('G', 0.5),
|
||||
Poisson('P', 1),
|
||||
Zeta('Z', 2)
|
||||
]
|
||||
size = 3
|
||||
numpy = import_module('numpy')
|
||||
if not numpy:
|
||||
skip('Numpy is not installed. Abort tests for _sample_numpy.')
|
||||
else:
|
||||
for X in distribs_numpy:
|
||||
samps = sample(X, size=size, library='numpy')
|
||||
for sam in samps:
|
||||
assert sam in X.pspace.domain.set
|
||||
raises(NotImplementedError,
|
||||
lambda: sample(Skellam('S', 1, 1), library='numpy'))
|
||||
raises(NotImplementedError,
|
||||
lambda: Skellam('S', 1, 1).pspace.distribution.sample(library='tensorflow'))
|
||||
|
||||
|
||||
def test_sample_scipy():
|
||||
p = S(2)/3
|
||||
x = Symbol('x', integer=True, positive=True)
|
||||
pdf = p*(1 - p)**(x - 1) # pdf of Geometric Distribution
|
||||
distribs_scipy = [
|
||||
DiscreteRV(x, pdf, set=S.Naturals),
|
||||
Geometric('G', 0.5),
|
||||
Logarithmic('L', 0.5),
|
||||
NegativeBinomial('N', 5, 0.4),
|
||||
Poisson('P', 1),
|
||||
Skellam('S', 1, 1),
|
||||
YuleSimon('Y', 1),
|
||||
Zeta('Z', 2)
|
||||
]
|
||||
size = 3
|
||||
scipy = import_module('scipy')
|
||||
if not scipy:
|
||||
skip('Scipy is not installed. Abort tests for _sample_scipy.')
|
||||
else:
|
||||
for X in distribs_scipy:
|
||||
samps = sample(X, size=size, library='scipy')
|
||||
samps2 = sample(X, size=(2, 2), library='scipy')
|
||||
for sam in samps:
|
||||
assert sam in X.pspace.domain.set
|
||||
for i in range(2):
|
||||
for j in range(2):
|
||||
assert samps2[i][j] in X.pspace.domain.set
|
||||
|
||||
|
||||
def test_sample_pymc():
|
||||
distribs_pymc = [
|
||||
Geometric('G', 0.5),
|
||||
Poisson('P', 1),
|
||||
NegativeBinomial('N', 5, 0.4)
|
||||
]
|
||||
size = 3
|
||||
pymc = import_module('pymc')
|
||||
if not pymc:
|
||||
skip('PyMC is not installed. Abort tests for _sample_pymc.')
|
||||
else:
|
||||
for X in distribs_pymc:
|
||||
samps = sample(X, size=size, library='pymc')
|
||||
for sam in samps:
|
||||
assert sam in X.pspace.domain.set
|
||||
raises(NotImplementedError,
|
||||
lambda: sample(Skellam('S', 1, 1), library='pymc'))
|
||||
|
||||
@slow
|
||||
def test_sample_discrete():
|
||||
X = Geometric('X', S.Half)
|
||||
scipy = import_module('scipy')
|
||||
if not scipy:
|
||||
skip('Scipy not installed. Abort tests')
|
||||
assert sample(X) in X.pspace.domain.set
|
||||
samps = sample(X, size=2) # This takes long time if ran without scipy
|
||||
for samp in samps:
|
||||
assert samp in X.pspace.domain.set
|
||||
|
||||
libraries = ['scipy', 'numpy', 'pymc']
|
||||
for lib in libraries:
|
||||
try:
|
||||
imported_lib = import_module(lib)
|
||||
if imported_lib:
|
||||
s0, s1, s2 = [], [], []
|
||||
s0 = sample(X, size=10, library=lib, seed=0)
|
||||
s1 = sample(X, size=10, library=lib, seed=0)
|
||||
s2 = sample(X, size=10, library=lib, seed=1)
|
||||
assert all(s0 == s1)
|
||||
assert not all(s1 == s2)
|
||||
except NotImplementedError:
|
||||
continue
|
||||
+94
@@ -0,0 +1,94 @@
|
||||
from sympy.core.numbers import Rational
|
||||
from sympy.core.singleton import S
|
||||
from sympy.external import import_module
|
||||
from sympy.stats import Binomial, sample, Die, FiniteRV, DiscreteUniform, Bernoulli, BetaBinomial, Hypergeometric, \
|
||||
Rademacher
|
||||
from sympy.testing.pytest import skip, raises
|
||||
|
||||
def test_given_sample():
|
||||
X = Die('X', 6)
|
||||
scipy = import_module('scipy')
|
||||
if not scipy:
|
||||
skip('Scipy is not installed. Abort tests')
|
||||
assert sample(X, X > 5) == 6
|
||||
|
||||
def test_sample_numpy():
|
||||
distribs_numpy = [
|
||||
Binomial("B", 5, 0.4),
|
||||
Hypergeometric("H", 2, 1, 1)
|
||||
]
|
||||
size = 3
|
||||
numpy = import_module('numpy')
|
||||
if not numpy:
|
||||
skip('Numpy is not installed. Abort tests for _sample_numpy.')
|
||||
else:
|
||||
for X in distribs_numpy:
|
||||
samps = sample(X, size=size, library='numpy')
|
||||
for sam in samps:
|
||||
assert sam in X.pspace.domain.set
|
||||
raises(NotImplementedError,
|
||||
lambda: sample(Die("D"), library='numpy'))
|
||||
raises(NotImplementedError,
|
||||
lambda: Die("D").pspace.sample(library='tensorflow'))
|
||||
|
||||
|
||||
def test_sample_scipy():
|
||||
distribs_scipy = [
|
||||
FiniteRV('F', {1: S.Half, 2: Rational(1, 4), 3: Rational(1, 4)}),
|
||||
DiscreteUniform("Y", list(range(5))),
|
||||
Die("D"),
|
||||
Bernoulli("Be", 0.3),
|
||||
Binomial("Bi", 5, 0.4),
|
||||
BetaBinomial("Bb", 2, 1, 1),
|
||||
Hypergeometric("H", 1, 1, 1),
|
||||
Rademacher("R")
|
||||
]
|
||||
|
||||
size = 3
|
||||
scipy = import_module('scipy')
|
||||
if not scipy:
|
||||
skip('Scipy not installed. Abort tests for _sample_scipy.')
|
||||
else:
|
||||
for X in distribs_scipy:
|
||||
samps = sample(X, size=size)
|
||||
samps2 = sample(X, size=(2, 2))
|
||||
for sam in samps:
|
||||
assert sam in X.pspace.domain.set
|
||||
for i in range(2):
|
||||
for j in range(2):
|
||||
assert samps2[i][j] in X.pspace.domain.set
|
||||
|
||||
|
||||
def test_sample_pymc():
|
||||
distribs_pymc = [
|
||||
Bernoulli('B', 0.2),
|
||||
Binomial('N', 5, 0.4)
|
||||
]
|
||||
size = 3
|
||||
pymc = import_module('pymc')
|
||||
if not pymc:
|
||||
skip('PyMC is not installed. Abort tests for _sample_pymc.')
|
||||
else:
|
||||
for X in distribs_pymc:
|
||||
samps = sample(X, size=size, library='pymc')
|
||||
for sam in samps:
|
||||
assert sam in X.pspace.domain.set
|
||||
raises(NotImplementedError,
|
||||
lambda: (sample(Die("D"), library='pymc')))
|
||||
|
||||
|
||||
def test_sample_seed():
|
||||
F = FiniteRV('F', {1: S.Half, 2: Rational(1, 4), 3: Rational(1, 4)})
|
||||
size = 10
|
||||
libraries = ['scipy', 'numpy', 'pymc']
|
||||
for lib in libraries:
|
||||
try:
|
||||
imported_lib = import_module(lib)
|
||||
if imported_lib:
|
||||
s0 = sample(F, size=size, library=lib, seed=0)
|
||||
s1 = sample(F, size=size, library=lib, seed=0)
|
||||
s2 = sample(F, size=size, library=lib, seed=1)
|
||||
assert all(s0 == s1)
|
||||
assert not all(s1 == s2)
|
||||
except NotImplementedError:
|
||||
continue
|
||||
Reference in New Issue
Block a user