def setUp(self):
'''
Saves the current random state for later recovery, sets the random seed
to get reproducible results and manually constructs a mixed vine.
'''
# Save random state for later recovery
self.random_state = np.random.get_state()
# Set fixed random seed
np.random.seed(0)
# Manually construct mixed vine
self.dim = 3 # Dimension
self.vine = MixedVine(self.dim)
# Specify marginals
self.vine.set_marginal(0, norm(0, 1))
self.vine.set_marginal(1, poisson(5))
self.vine.set_marginal(2, gamma(2, 0, 4))
# Specify pair copulas
self.vine.set_copula(1, 0, GaussianCopula(0.5))
self.vine.set_copula(1, 1, FrankCopula(4))
self.vine.set_copula(2, 0, ClaytonCopula(5))
python类poisson()的实例源码
def nbinom(self,samples):
"""
Sampling from a Negative binomial distribution
Parameters:
mu= poissonon mean
r controls the deviation from the poisson
This makes the negative binomial distribution suitable as a robust
alternative to the Poisson, which approaches the Poisson for large r,
but which has larger variance than the Poisson for small r.
------------------------------------------------------------------------
- samples: number of values that will be returned.
"""
mu=float(self.__params[0])
r=float(self.__params[1])
p=(r*1.0)/(r+mu)
distro=nbinom(r,p)
f=distro.rvs(size=samples)
return f
def sample_spatial_poisson_process(self, rate):
xmin, xmax = self.x_range
ymin, ymax = self.y_range
dx = xmax - xmin
dy = ymax - ymin
N = stats.poisson( rate * dx * dy ).rvs()
x = stats.uniform.rvs(xmin, dx, ((N, 1)) )
y = stats.uniform.rvs(ymin, dy, ((N, 1)) )
centers = np.hstack((x,y))
return centers
def poissonRnd(scale, size=None):
result = np.random.poisson(scale, size)
return result
def value(self,samples=1):
"""
Samples number of values given from the specific distribution.
------------------------------------------------------------------------
- samples: number of values that will be returned.
"""
value=0
try:
for item in self.__params:
if item==0: break
if item==0: value=[0]*samples
else:
if self.__name=="b": value=self.binom(samples)
if self.__name=="e": value=self.exponential(samples)
if self.__name=="f": value=self.fixed(samples)
if self.__name=="g": value=self.gamma(samples)
if self.__name=="g1": value=self.gamma1(samples)
if self.__name=="ln": value=self.lognormal(samples)
if self.__name=="n": value=self.normal(samples)
if self.__name=="nb": value=self.nbinom(samples)
if self.__name=="p": value=self.poisson(samples)
if self.__name=="u": value=self.uniform(samples)
except Exception as ex:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
message="\n\tUnexpected: {0} | {1} - File: {2} - Line:{3}".format(\
ex,exc_type, fname, exc_tb.tb_lineno)
status=False
raise Exception(message)
# self.appLogger.error(message)
# sys.exit()
return value
def poisson(self,samples):
"""
Sampling from a Poisson distribution
Parameters:
mean
------------------------------------------------------------------------
- samples: number of values that will be returned.
"""
l=float(self.__params[0]*1.0)
distro=poisson(l)
f=distro.rvs(size=samples)
return f
def gen(self, normal_mu_range, anomaly_mu_range):
self.gens = [
compound_distribution(
stats.uniform(loc=anomaly_mu_range[0], scale=anomaly_mu_range[1] - anomaly_mu_range[0]),
truncated(stats.poisson, max_value=1024)
),
compound_distribution(
stats.uniform(loc=normal_mu_range[0], scale=normal_mu_range[1] - normal_mu_range[0]),
truncated(stats.poisson, max_value=1024)
)
]
self.priors = np.array([0.1, 0.9])
n = 10
MC = CameraMC(self.priors, self.gens, image_shape=(1, n, n), n_frames=100)
self.cats, self.params, self.imgs = MC.get_sample()
self.hists = ndcount(self.imgs).reshape(n, n, -1)
self.hists = self.hists.astype('float32') / np.sum(self.hists, axis=2)[:, :, None]
self.cats = self.cats.reshape(-1)
print("Img shape %s" % (self.imgs.shape, ))
print("Hists shape %s" % (self.hists.shape, ))
print("Categories shape %s" % (self.cats.shape, ))
def gen(self, normal_mu_range, anomaly_mu_range):
self.gens = [
compound_distribution(
stats.uniform(loc=anomaly_mu_range[0], scale=anomaly_mu_range[1] - anomaly_mu_range[0]),
truncated(stats.poisson, max_value=1024)
),
compound_distribution(
stats.uniform(loc=normal_mu_range[0], scale=normal_mu_range[1] - normal_mu_range[0]),
truncated(stats.poisson, max_value=1024)
)
]
self.priors = np.array([0.1, 0.9])
n = 100
m = 10
bins = 64
MC = CameraMC(self.priors, self.gens, image_shape=(1, n, ), n_frames=100, max_value=bins)
X = np.ndarray(shape=(m, n, bins), dtype='float32')
cats = np.ndarray(shape=(m, n), dtype='float32')
for i in xrange(m):
cats[i], _, imgs = MC.get_sample()
h = ndcount(imgs, bins=bins)
print h.shape
h = h.reshape(n, bins)
X[i] = h.astype('float32') / np.sum(h, axis=1)[:, None]
print("X shape %s" % (X.shape, ))
print("Categories shape %s" % (cats.shape, ))
self.X = X
self.cats = cats
def __init__(self, parameter_distribution = stats.gamma,
signal_family = stats.poisson):
self.parameter_distribution = parameter_distribution
self.signal_family = signal_family
def fit(samples, is_continuous):
'''
Fits a distribution to the given samples.
Parameters
----------
samples : array_like
Array of samples.
is_continuous : bool
If `True` then a continuous distribution is fitted. Otherwise, a
discrete distribution is fitted.
Returns
-------
best_marginal : Marginal
The distribution fitted to `samples`.
'''
# Mean and variance
mean = np.mean(samples)
var = np.var(samples)
# Set suitable distributions
if is_continuous:
if np.any(samples <= 0):
options = [norm]
else:
options = [norm, gamma]
else:
if var > mean:
options = [poisson, binom, nbinom]
else:
options = [poisson, binom]
params = np.empty(len(options), dtype=object)
marginals = np.empty(len(options), dtype=object)
# Fit parameters and construct marginals
for i, dist in enumerate(options):
if dist == poisson:
params[i] = [mean]
elif dist == binom:
param_n = np.max(samples)
param_p = np.sum(samples) / (param_n * len(samples))
params[i] = [param_n, param_p]
elif dist == nbinom:
param_n = mean * mean / (var - mean)
param_p = mean / var
params[i] = [param_n, param_p]
else:
params[i] = dist.fit(samples)
rv_mixed = dist(*params[i])
marginals[i] = Marginal(rv_mixed)
# Calculate Akaike information criterion
aic = np.zeros(len(options))
for i, marginal in enumerate(marginals):
aic[i] = 2 * len(params[i]) \
- 2 * np.sum(marginal.logpdf(samples))
best_marginal = marginals[np.argmin(aic)]
return best_marginal
