# Python numpy.random() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

```def isotropic_mean_shift(self):
"""normalized last mean shift, under random selection N(0,I)

distributed.

Caveat: while it is finite and close to sqrt(n) under random
selection, the length of the normalized mean shift under
*systematic* selection (e.g. on a linear function) tends to
infinity for mueff -> infty. Hence it must be used with great
care for large mueff.
"""
z = self.sm.transform_inverse((self.mean - self.mean_old) /
self.sigma_vec.scaling)
# works unless a re-parametrisation has been done
# assert Mh.vequals_approximately(z, np.dot(es.B, (1. / es.D) *
#         np.dot(es.B.T, (es.mean - es.mean_old) / es.sigma_vec)))
z /= self.sigma * self.sp.cmean
z *= self.sp.weights.mueff**0.5
return z ```

Example 2

```def _random_vec(sites, ldim, randstate=None, dtype=np.complex_):
"""Returns a random complex vector (normalized to ||x||_2 = 1) of shape
(ldim,) * sites, i.e. a pure state with local dimension `ldim` living on
`sites` sites.

:param sites: Number of local sites
:param ldim: Local ldimension
:param randstate: numpy.random.RandomState instance or None
:returns: numpy.ndarray of shape (ldim,) * sites

>>> psi = _random_vec(5, 2); psi.shape
(2, 2, 2, 2, 2)
>>> np.abs(np.vdot(psi, psi) - 1) < 1e-6
True
"""
shape = (ldim, ) * sites
psi = _randfuncs[dtype](shape, randstate=randstate)
psi /= np.linalg.norm(psi)
return psi ```

Example 3

```def random_mps(sites, ldim, rank, randstate=None, force_rank=False):
"""Returns a randomly choosen normalized matrix product state

:param sites: Number of sites
:param ldim: Local dimension
:param rank: Rank
:param randstate: numpy.random.RandomState instance or None
:param force_rank: If True, the rank is exaclty `rank`.
Otherwise, it might be reduced if we reach the maximum sensible rank.
:returns: randomly choosen matrix product (pure) state

>>> mps = random_mps(4, 2, 10, force_rank=True)
>>> mps.ranks, mps.shape
((10, 10, 10), ((2,), (2,), (2,), (2,)))
>>> mps.canonical_form
(0, 4)
>>> round(abs(1 - mp.inner(mps, mps)), 10)
0.0

"""
return random_mpa(sites, ldim, rank, normalized=True, randstate=randstate,
force_rank=force_rank, dtype=np.complex_) ```

Example 4

```def _standard_normal(shape, randstate=np.random, dtype=np.float_):
"""Generates a standard normal numpy array of given shape and dtype, i.e.
this function is equivalent to `randstate.randn(*shape)` for real dtype and
`randstate.randn(*shape) + 1.j * randstate.randn(shape)` for complex dtype.

:param tuple shape: Shape of array to be returned
:param randstate: An instance of :class:`numpy.random.RandomState` (default is
``np.random``))
:param dtype: ``np.float_`` (default) or `np.complex_`

Returns
-------

A: An array of given shape and dtype with standard normal entries

"""
if dtype == np.float_:
return randstate.randn(*shape)
elif dtype == np.complex_:
return randstate.randn(*shape) + 1.j * randstate.randn(*shape)
else:
raise ValueError('{} is not a valid dtype.'.format(dtype)) ```

Example 5

```def setup_params(self, data):
keys = ('fun_data', 'fun_y', 'fun_ymin', 'fun_ymax')
if not any(self.params[k] for k in keys):
raise PlotnineError('No summary function')

if self.params['fun_args'] is None:
self.params['fun_args'] = {}

if 'random_state' not in self.params['fun_args']:
if self.params['random_state']:
random_state = self.params['random_state']
if random_state is None:
random_state = np.random
elif isinstance(random_state, int):
random_state = np.random.RandomState(random_state)

self.params['fun_args']['random_state'] = random_state

return self.params ```

Example 6

```def bootstrap_statistics(series, statistic, n_samples=1000,
confidence_interval=0.95, random_state=None):
"""
Default parameters taken from
R's Hmisc smean.cl.boot
"""
if random_state is None:
random_state = np.random

alpha = 1 - confidence_interval
size = (n_samples, len(series))
inds = random_state.randint(0, len(series), size=size)
samples = series.values[inds]
means = np.sort(statistic(samples, axis=1))
return pd.DataFrame({'ymin': means[int((alpha/2)*n_samples)],
'ymax': means[int((1-alpha/2)*n_samples)],
'y': [statistic(series)]}) ```

Example 7

```def setup_params(self, data):
keys = ('fun_data', 'fun_y', 'fun_ymin', 'fun_ymax')
if not any(self.params[k] for k in keys):
raise PlotnineError('No summary function')

if self.params['fun_args'] is None:
self.params['fun_args'] = {}

if 'random_state' not in self.params['fun_args']:
if self.params['random_state']:
random_state = self.params['random_state']
if random_state is None:
random_state = np.random
elif isinstance(random_state, int):
random_state = np.random.RandomState(random_state)

self.params['fun_args']['random_state'] = random_state

return self.params ```

Example 8

```def mahalanobis_norm(self, dx):
"""compute the Mahalanobis norm that is induced by the adapted
sample distribution, covariance matrix ``C`` times ``sigma**2``,
including ``sigma_vec``. The expected Mahalanobis distance to
the sample mean is about ``sqrt(dimension)``.

Argument
--------
A *genotype* difference `dx`.

Example
-------
>>> import cma, numpy
>>> es = cma.CMAEvolutionStrategy(numpy.ones(10), 1)
>>> xx = numpy.random.randn(2, 10)
>>> d = es.mahalanobis_norm(es.gp.geno(xx[0]-xx[1]))

`d` is the distance "in" the true sample distribution,
sampled points have a typical distance of ``sqrt(2*es.N)``,
where ``es.N`` is the dimension, and an expected distance of
close to ``sqrt(N)`` to the sample mean. In the example,
`d` is the Euclidean distance, because C = I and sigma = 1.

"""
return sqrt(sum((self.D**-1. * np.dot(self.B.T, dx / self.sigma_vec))**2)) / self.sigma ```

Example 9

```def __call__(self, x, inverse=False):  # function when calling an object
"""Rotates the input array `x` with a fixed rotation matrix
(``self.dicMatrices['str(len(x))']``)
"""
x = np.array(x, copy=False)
N = x.shape[0]  # can be an array or matrix, TODO: accept also a list of arrays?
if str(N) not in self.dicMatrices:  # create new N-basis for once and all
rstate = np.random.get_state()
np.random.seed(self.seed) if self.seed else np.random.seed()
B = np.random.randn(N, N)
for i in range(N):
for j in range(0, i):
B[i] -= np.dot(B[i], B[j]) * B[j]
B[i] /= sum(B[i]**2)**0.5
self.dicMatrices[str(N)] = B
np.random.set_state(rstate)
if inverse:
return np.dot(self.dicMatrices[str(N)].T, x)  # compute rotation
else:
return np.dot(self.dicMatrices[str(N)], x)  # compute rotation
# Use rotate(x) to rotate x ```

Example 10

```def elli(self, x, rot=0, xoffset=0, cond=1e6, actuator_noise=0.0, both=False):
"""Ellipsoid test objective function"""
if not isscalar(x[0]):  # parallel evaluation
return [self.elli(xi, rot) for xi in x]  # could save 20% overall
if rot:
x = rotate(x)
N = len(x)
if actuator_noise:
x = x + actuator_noise * np.random.randn(N)

ftrue = sum(cond**(np.arange(N) / (N - 1.)) * (x + xoffset)**2)

alpha = 0.49 + 1. / N
beta = 1
felli = np.random.rand(1)[0]**beta * ftrue * \
max(1, (10.**9 / (ftrue + 1e-99))**(alpha * np.random.rand(1)[0]))
# felli = ftrue + 1*np.random.randn(1)[0] / (1e-30 +
#                                           np.abs(np.random.randn(1)[0]))**0
if both:
return (felli, ftrue)
else:
# return felli  # possibly noisy value
return ftrue  # + np.random.randn() ```

Example 11

```def __init__(
self,
batch_size,
training_epoch_size=None,
no_stub_batch=False,
shuffle=None,
seed=None,
buffer_size=2,
):
self.batch_size = batch_size
self.training_epoch_size = training_epoch_size
self.no_stub_batch = no_stub_batch

self.shuffle = shuffle
if seed is not None:
self.random = np.random.RandomState(seed)
else:
self.random = np.random

self.buffer_size = buffer_size ```

Example 12

```def test_process_image(compress, out_dir):
numpy.random.seed(8)
image = numpy.random.randint(256, size=(16, 16, 3), dtype=numpy.uint16)

meta = {
}
compress.stats["illum_correction_function"] = numpy.ones((16,16,3))
compress.stats["upper_percentiles"] = [255, 255, 255]
compress.stats["lower_percentiles"] = [0, 0, 0]

compress.process_image(0, image, meta)

filenames = glob.glob(os.path.join(out_dir,"*"))
real_filenames = [os.path.join(out_dir, x) for x in ["dna.png", "er.png", "mito.png"]]
filenames.sort()

assert real_filenames == filenames

for i in range(3):
numpy.testing.assert_array_equal(image[:,:,i], data) ```

Example 13

```def test_apply(corrector):
image = numpy.random.randint(256, size=(24, 24, 3), dtype=numpy.uint16)

illum_corr_func = numpy.random.rand(24, 24, 3)

illum_corr_func /= illum_corr_func.min()

corrector.illum_corr_func = illum_corr_func

corrected = corrector.apply(image)

expected = image / illum_corr_func

assert corrected.shape == (24, 24, 3)

numpy.testing.assert_array_equal(corrected, expected) ```

Example 14

```def estimate(self, context, data):
pdf = ScaleMixture()
alpha = context.prior.alpha
beta = context.prior.beta
d = context._d

if len(data.shape) == 1:
data = data[:, numpy.newaxis]

a = alpha + 0.5 * d * len(data.shape)
b = beta + 0.5 * data.sum(-1) ** 2

s = numpy.clip(numpy.random.gamma(a, 1. / b), 1e-20, 1e10)
pdf.scales = s

context.prior.estimate(s)
pdf.prior = context.prior

return pdf ```

Example 15

```def testRandom(self):

ig = InverseGaussian(1., 1.)
samples = ig.random(1000000)
mu = numpy.mean(samples)
var = numpy.var(samples)

self.assertAlmostEqual(ig.mu, mu, delta=1e-1)
self.assertAlmostEqual(ig.mu ** 3 / ig.shape, var, delta=1e-1)

ig = InverseGaussian(3., 6.)

samples = ig.random(1000000)
mu = numpy.mean(samples)
var = numpy.var(samples)

self.assertAlmostEqual(ig.mu, mu, delta=1e-1)
self.assertAlmostEqual(ig.mu ** 3 / ig.shape, var, delta=5e-1) ```

Example 16

```def testRandom(self):

from scipy.special import kv
from numpy import sqrt

a = 2.
b = 1.
p = 1
gig = GeneralizedInverseGaussian(a, b, p)
samples = gig.random(10000)

mu_analytical = sqrt(b) * kv(p + 1, sqrt(a * b)) / (sqrt(a) * kv(p, sqrt(a * b)))

var_analytical = b * kv(p + 2, sqrt(a * b)) / a / kv(p, sqrt(a * b)) - mu_analytical ** 2

mu = numpy.mean(samples)
var = numpy.var(samples)

self.assertAlmostEqual(mu_analytical, mu, delta=1e-1)
self.assertAlmostEqual(var_analytical, var, delta=1e-1) ```

Example 17

```def _check_random_state(seed):
"""Turn seed into a np.random.RandomState instance

If seed is None, return the RandomState singleton used by np.random.
If seed is an int, return a new RandomState instance seeded with seed.
If seed is already a RandomState instance, return it.
Otherwise raise ValueError.
"""
if seed is None or seed is np.random:
return np.random.mtrand._rand
if isinstance(seed, int):
return np.random.RandomState(seed)
if isinstance(seed, np.random.RandomState):
return seed
raise ValueError('%r cannot be used to seed a numpy.random.RandomState'
' instance' % seed) ```

Example 18

```def test_poisson(self):
"""Tests that Gibbs sampling the initial process yields a Poisson process."""
nt = 50
ns = 1000
num_giter = 5
net = self.poisson

times = []
for i in range(ns):
arrv = net.sample (nt)
obs = arrv.subset (lambda a,e: a.is_last_in_queue(e), copy_evt)
gsmp = net.gibbs_resample (arrv, 0, num_giter)
resampled = gsmp[-1]
times.append (evts[0].d)

exact_sample = [ numpy.random.gamma (shape=3, scale=0.5) for i in xrange (ns) ]
times.sort()
exact_sample.sort()

print summarize(times)
print summarize(exact_sample)

netutils.check_quantiles (self, exact_sample, times, ns) ```

Example 19

```def _sample_testset(self, data):
test_sample = self.test_sample
if not isinstance(test_sample, int):
return data

userid, feedback = self.fields.userid, self.fields.feedback
if test_sample > 0:
sampled = (data.groupby(userid, sort=False, group_keys=False)
.apply(random_choice, test_sample, self.random_state or np.random))
elif test_sample < 0: #leave only the most negative feedback from user
idx = (data.groupby(userid, sort=False)[feedback]
.nsmallest(-test_sample).index.get_level_values(1))
sampled = data.loc[idx]
else:
sampled = data

return sampled ```

Example 20

```def mahalanobis_norm(self, dx):
"""compute the Mahalanobis norm that is induced by the adapted
sample distribution, covariance matrix ``C`` times ``sigma**2``,
including ``sigma_vec``. The expected Mahalanobis distance to
the sample mean is about ``sqrt(dimension)``.

Argument
--------
A *genotype* difference `dx`.

Example
-------
>>> import cma, numpy
>>> es = cma.CMAEvolutionStrategy(numpy.ones(10), 1)
>>> xx = numpy.random.randn(2, 10)
>>> d = es.mahalanobis_norm(es.gp.geno(xx[0]-xx[1]))

`d` is the distance "in" the true sample distribution,
sampled points have a typical distance of ``sqrt(2*es.N)``,
where ``es.N`` is the dimension, and an expected distance of
close to ``sqrt(N)`` to the sample mean. In the example,
`d` is the Euclidean distance, because C = I and sigma = 1.

"""
return sqrt(sum((self.D**-1. * np.dot(self.B.T, dx / self.sigma_vec))**2)) / self.sigma ```

Example 21

```def __call__(self, x, inverse=False):  # function when calling an object
"""Rotates the input array `x` with a fixed rotation matrix
(``self.dicMatrices['str(len(x))']``)
"""
x = np.array(x, copy=False)
N = x.shape[0]  # can be an array or matrix, TODO: accept also a list of arrays?
if str(N) not in self.dicMatrices:  # create new N-basis for once and all
rstate = np.random.get_state()
np.random.seed(self.seed) if self.seed else np.random.seed()
B = np.random.randn(N, N)
for i in range(N):
for j in range(0, i):
B[i] -= np.dot(B[i], B[j]) * B[j]
B[i] /= sum(B[i]**2)**0.5
self.dicMatrices[str(N)] = B
np.random.set_state(rstate)
if inverse:
return np.dot(self.dicMatrices[str(N)].T, x)  # compute rotation
else:
return np.dot(self.dicMatrices[str(N)], x)  # compute rotation
# Use rotate(x) to rotate x ```

Example 22

```def elli(self, x, rot=0, xoffset=0, cond=1e6, actuator_noise=0.0, both=False):
"""Ellipsoid test objective function"""
if not isscalar(x[0]):  # parallel evaluation
return [self.elli(xi, rot) for xi in x]  # could save 20% overall
if rot:
x = rotate(x)
N = len(x)
if actuator_noise:
x = x + actuator_noise * np.random.randn(N)

ftrue = sum(cond**(np.arange(N) / (N - 1.)) * (x + xoffset)**2)

alpha = 0.49 + 1. / N
beta = 1
felli = np.random.rand(1)[0]**beta * ftrue * \
max(1, (10.**9 / (ftrue + 1e-99))**(alpha * np.random.rand(1)[0]))
# felli = ftrue + 1*np.random.randn(1)[0] / (1e-30 +
#                                           np.abs(np.random.randn(1)[0]))**0
if both:
return (felli, ftrue)
else:
# return felli  # possibly noisy value
return ftrue  # + np.random.randn() ```

Example 23

```def elastic_transform(image, alpha, sigma, random_state=None):
"""Elastic deformation of images as described in [Simard2003]_.
.. [Simard2003] Simard, Steinkraus and Platt, "Best Practices for
Convolutional Neural Networks applied to Visual Document Analysis", in
Proc. of the International Conference on Document Analysis and
Recognition, 2003.
"""
if random_state is None:
random_state = np.random.RandomState(None)

shape = image.shape[1:];
dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode="constant", cval=0) * alpha
dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode="constant", cval=0) * alpha
x, y = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]))
indices = np.reshape(y+dy, (-1, 1)), np.reshape(x+dx, (-1, 1))

#return map_coordinates(image, indices, order=1).reshape(shape)
res = np.zeros_like(image);
for i in xrange(image.shape[0]):
res[i] = map_coordinates(image[i], indices, order=1).reshape(shape)
return res; ```

Example 24

```def load_augment(fname, w, h, aug_params=no_augmentation_params,
transform=None, sigma=0.0, color_vec=None):
"""Load augmented image with output shape (w, h).

Default arguments return non augmented image of shape (w, h).
To apply a fixed transform (color augmentation) specify transform
(color_vec).
To generate a random augmentation specify aug_params and sigma.
"""
if transform is None:
img = perturb(img, augmentation_params=aug_params, target_shape=(w, h))
else:
img = perturb_fixed(img, tform_augment=transform, target_shape=(w, h))

np.subtract(img, MEAN[:, np.newaxis, np.newaxis], out=img)
np.divide(img, STD[:, np.newaxis, np.newaxis], out=img)
img = augment_color(img, sigma=sigma, color_vec=color_vec)
return img ```

Example 25

```def mahalanobis_norm(self, dx):
"""compute the Mahalanobis norm that is induced by the adapted
sample distribution, covariance matrix ``C`` times ``sigma**2``,
including ``sigma_vec``. The expected Mahalanobis distance to
the sample mean is about ``sqrt(dimension)``.

Argument
--------
A *genotype* difference `dx`.

Example
-------
>>> import cma, numpy
>>> es = cma.CMAEvolutionStrategy(numpy.ones(10), 1)
>>> xx = numpy.random.randn(2, 10)
>>> d = es.mahalanobis_norm(es.gp.geno(xx[0]-xx[1]))

`d` is the distance "in" the true sample distribution,
sampled points have a typical distance of ``sqrt(2*es.N)``,
where ``es.N`` is the dimension, and an expected distance of
close to ``sqrt(N)`` to the sample mean. In the example,
`d` is the Euclidean distance, because C = I and sigma = 1.

"""
return sqrt(sum((self.D**-1. * np.dot(self.B.T, dx / self.sigma_vec))**2)) / self.sigma ```

Example 26

```def __call__(self, x, inverse=False):  # function when calling an object
"""Rotates the input array `x` with a fixed rotation matrix
(``self.dicMatrices['str(len(x))']``)
"""
x = np.array(x, copy=False)
N = x.shape[0]  # can be an array or matrix, TODO: accept also a list of arrays?
if str(N) not in self.dicMatrices:  # create new N-basis for once and all
rstate = np.random.get_state()
np.random.seed(self.seed) if self.seed else np.random.seed()
B = np.random.randn(N, N)
for i in xrange(N):
for j in xrange(0, i):
B[i] -= np.dot(B[i], B[j]) * B[j]
B[i] /= sum(B[i]**2)**0.5
self.dicMatrices[str(N)] = B
np.random.set_state(rstate)
if inverse:
return np.dot(self.dicMatrices[str(N)].T, x)  # compute rotation
else:
return np.dot(self.dicMatrices[str(N)], x)  # compute rotation
# Use rotate(x) to rotate x ```

Example 27

```def elli(self, x, rot=0, xoffset=0, cond=1e6, actuator_noise=0.0, both=False):
"""Ellipsoid test objective function"""
if not isscalar(x[0]):  # parallel evaluation
return [self.elli(xi, rot) for xi in x]  # could save 20% overall
if rot:
x = rotate(x)
N = len(x)
if actuator_noise:
x = x + actuator_noise * np.random.randn(N)

ftrue = sum(cond**(np.arange(N) / (N - 1.)) * (x + xoffset)**2)

alpha = 0.49 + 1. / N
beta = 1
felli = np.random.rand(1)[0]**beta * ftrue * \
max(1, (10.**9 / (ftrue + 1e-99))**(alpha * np.random.rand(1)[0]))
# felli = ftrue + 1*np.random.randn(1)[0] / (1e-30 +
#                                           np.abs(np.random.randn(1)[0]))**0
if both:
return (felli, ftrue)
else:
# return felli  # possibly noisy value
return ftrue  # + np.random.randn() ```

Example 28

```def form_set_data(labels, max_num, verbose=False):
"""Generate label sets from sample labels.

For each sample, generate a set by random sampling within the same class.
Set is a tensor
"""
# group sample ids based on label.
label_ids = {}
for idx in range(labels.size):
if labels[idx] not in label_ids:
label_ids[labels[idx]] = []
label_ids[labels[idx]].append(idx)
set_ids = {}
for idx in range(labels.size):
samp_ids = label_ids[labels[idx]][:]
samp_num = min(max_num, len(samp_ids))
set_ids[idx] = rand.sample(samp_ids, samp_num)
if verbose:
print "set {} formed.".format(idx)
return set_ids ```

Example 29

```def rvs(cls, a, b, size=1, random_state=None):
"""Draw random variates.

Parameters
----------
a : float or array-like
b : float or array-like
size : int, optional
random_state : RandomState, optional

Returns
-------
np.array

"""
u = ss.uniform.rvs(loc=a, scale=b-a, size=size, random_state=random_state)
x = np.exp(u)
return x ```

Example 30

```def rvs(cls, b, size=1, random_state=None):
"""Get random variates.

Parameters
----------
b : float
size : int or tuple, optional
random_state : RandomState, optional

Returns
-------
arraylike

"""
u = ss.uniform.rvs(loc=0, scale=1, size=size, random_state=random_state)
t1 = np.where(u < 0.5, np.sqrt(2. * u) * b - b, -np.sqrt(2. * (1. - u)) * b + b)
return t1 ```

Example 31

```def rvs(self, size=None, random_state=None):
"""Sample the joint prior."""
random_state = np.random if random_state is None else random_state

context = ComputationContext(size or 1, seed='global')

# Change to the correct random_state instance
# TODO: allow passing random_state to ComputationContext seed

rvs = np.column_stack([batch[p] for p in self.parameter_names])

if self.dim == 1:
rvs = rvs.reshape(size or 1)

return rvs[0] if size is None else rvs ```

Example 32

```def raw_to_floatX(imb, pixel_shift=0.5, square=True, center=False, rng=None):
rng = rng if rng else np.random
w,h = imb.shape[2], imb.shape[3] # image size
x, y = 0,0 # offsets
if square:
if w > h:
if center:
x = (w-h)/2
else:
x = rng.randint(w-h)
w=h
elif h > w:
if center:
y = (h-w)/2
else:
y = rng.randint(h-w)
h=w
return nn.utils.floatX(imb)[:,:,x:x+w,y:y+h]/ 255. - pixel_shift

# creates and hdf5 file from a dataset given a split in the form {'train':(0,n)}, etc
# appears to save in unpredictable order, so order must be verified after creation ```

Example 33

```def batch_loader(self, rnd_gen=np.random, shuffle=True):
"""load_mbs yields a new minibatch at each iteration"""
batchsize = self.batchsize
inds = np.arange(self.n_samples)
if shuffle:
rnd_gen.shuffle(inds)
n_mbs = np.int(np.ceil(self.n_samples / batchsize))

x = np.zeros(self.X_shape, np.float32)
y = np.zeros(self.y_shape, np.float32)
ids = np.empty((batchsize,), np.object_)

for m in range(n_mbs):
start = m * batchsize
end = (m + 1) * batchsize
if end > self.n_samples:
end = self.n_samples
mb_slice = slice(start, end)

x[:end - start, :] = self.x[inds[mb_slice], :]
y[:end - start, :] = self.y[inds[mb_slice], :]
ids[:end - start] = self.ids[inds[mb_slice]]

yield dict(X=x, y=y, ID=ids) ```

Example 34

```def batch_loader(self, rnd_gen=np.random, shuffle=True):
"""load_mbs yields a new minibatch at each iteration"""
batchsize = self.batchsize
inds = np.arange(self.n_samples)
if shuffle:
rnd_gen.shuffle(inds)
n_mbs = np.int(np.ceil(self.n_samples / batchsize))

x = np.zeros(self.X_shape, np.float32)
y = np.zeros(self.y_shape, np.float32)
ids = np.empty((batchsize,), np.object_)

for m in range(n_mbs):
start = m * batchsize
end = (m + 1) * batchsize
if end > self.n_samples:
end = self.n_samples
mb_slice = slice(start, end)

x[:end - start, :] = self.x[inds[mb_slice], :]
y[:end - start, :] = self.y[inds[mb_slice], :]
ids[:end - start] = self.ids[inds[mb_slice]]

yield dict(X=x, y=y, ID=ids) ```

Example 35

```def __init__(self, n_samples, duration, *ops, **kwargs):

super(Sampler, self).__init__(*ops)

self.n_samples = n_samples
self.duration = duration

random_state = kwargs.pop('random_state', None)

if random_state is None:
self.rng = np.random
elif isinstance(random_state, int):
self.rng = np.random.RandomState(seed=random_state)
elif isinstance(random_state, np.random.RandomState):
self.rng = random_state
else:
raise ParameterError('Invalid random_state={}'.format(random_state)) ```

Example 36

```def __init__(self, data, rng=None):
if rng is None:
rng = np.random

if is_integer(data):
if data < 1:
raise ValidationError("Number of dimensions must be a "
"positive int", attr='data', obj=self)

self.v = rng.randn(data)
self.v /= np.linalg.norm(self.v)
else:
self.v = np.array(data, dtype=float)
if len(self.v.shape) != 1:
raise ValidationError("'data' must be a vector", 'data', self)
self.v.setflags(write=False) ```

Example 37

```def mahalanobis_norm(self, dx):
"""return Mahalanobis norm based on the current sample
distribution.

The norm is based on Covariance matrix ``C`` times ``sigma**2``,
and includes ``sigma_vec``. The expected Mahalanobis distance to
the sample mean is about ``sqrt(dimension)``.

Argument
--------
A *genotype* difference `dx`.

Example
-------
>>> import cma, numpy
>>> es = cma.CMAEvolutionStrategy(numpy.ones(10), 1)  #doctest: +ELLIPSIS
(5_w,...
>>> xx = numpy.random.randn(2, 10)
>>> d = es.mahalanobis_norm(es.gp.geno(xx[0]-xx[1]))

`d` is the distance "in" the true sample distribution,
sampled points have a typical distance of ``sqrt(2*es.N)``,
where ``es.N`` is the dimension, and an expected distance of
close to ``sqrt(N)`` to the sample mean. In the example,
`d` is the Euclidean distance, because C = I and sigma = 1.

"""
return self.sm.norm(np.asarray(dx) / self.sigma_vec.scaling) / self.sigma ```

Example 38

```def get_rng():
"""Get the package-level random number generator.

Returns
-------
:class:`numpy.random.RandomState` instance
The :class:`numpy.random.RandomState` instance passed to the most
recent call of :func:`set_rng`, or ``numpy.random`` if :func:`set_rng`
has never been called.
"""
return _rng ```

Example 39

```def set_rng(rng):
"""Set the package-level random number generator.

Parameters
----------
new_rng : ``numpy.random`` or a :class:`numpy.random.RandomState` instance
The random number generator to use.
"""
global _rng
_rng = rng ```

Example 40

```def set_seed(seed):
"""Set numpy seed.

Parameters
----------
seed : int
"""
global _rng
_rng = np.random.RandomState(seed) ```

Example 41

```def __init__(self, db, keys, rng=np.random):
super(DataIterator, self).__init__()
self.db = db
self.keys = keys
self.rng = rng

# If there is only one key, wrap it in a list
if isinstance(self.keys, str):
self.keys = [self.keys]

# Retrieve the data specification (shape & dtype) for all data objects
# Assumes that all samples have the same shape and data type
self.spec = db.get_data_specification(0) ```

Example 42

```def __init__(self, db, keys, batch_size, shuffle=False, endless=True,
rng=np.random):
super(SimpleBatch, self).__init__(db, keys, rng)
self.batch_size = batch_size
self.shuffle = shuffle
self.endless = endless

# Set up Python generator
self.gen = self.batch() ```

Example 43

```def __init__(self, db, keys, batch_size, shuffle=False, endless=True,
rng=np.random):
shuffle, endless, rng) ```

Example 44

```def __init__(self, db, keys, batch_size, rng=np.random):
super(StochasticBatch, self).__init__(db, keys, rng)
self.batch_size = batch_size

# Set up Python generator
self.gen = self.batch() ```

Example 45

```def __init__(self, db, keys, batch_size, rng=np.random):
rng) ```

Example 46

```def random_lowrank(rows, cols, rank, randstate=np.random, dtype=np.float_):
"""Returns a random lowrank matrix of given shape and dtype"""
if dtype == np.float_:
A = randstate.randn(rows, rank)
B = randstate.randn(cols, rank)
elif dtype == np.complex_:
A = randstate.randn(rows, rank) + 1.j * randstate.randn(rows, rank)
B = randstate.randn(cols, rank) + 1.j * randstate.randn(cols, rank)
else:
raise ValueError("{} is not a valid dtype".format(dtype))

C = A.dot(B.conj().T)
return C / np.linalg.norm(C) ```

Example 47

```def random_fullrank(rows, cols, **kwargs):
"""Returns a random matrix of given shape and dtype. Should provide
same interface as random_lowrank"""
kwargs.pop('rank', None)
return random_lowrank(rows, cols, min(rows, cols), **kwargs) ```

Example 48

```def _zrandn(shape, randstate=None):
"""Shortcut for :code:`np.random.randn(*shape) + 1.j *
np.random.randn(*shape)`

:param randstate: Instance of np.radom.RandomState or None (which yields
the default np.random) (default None)

"""
randstate = randstate if randstate is not None else np.random
return randstate.randn(*shape) + 1.j * randstate.randn(*shape) ```

Example 49

```def _randn(shape, randstate=None):
"""Shortcut for :code:`np.random.randn(*shape)`

:param randstate: Instance of np.radom.RandomState or None (which yields
the default np.random) (default None)

"""
randstate = randstate if randstate is not None else np.random
return randstate.randn(*shape) ```

Example 50

```def _random_state(sites, ldim, randstate=None):
"""Returns a random positive semidefinite operator of shape (ldim, ldim) *
sites normalized to Tr rho = 1, i.e. a mixed state with local dimension
`ldim` living on `sites` sites. Note that the returned state is positive
semidefinite only when interpreted in global form (see
:func:`tools.global_to_local`)

:param sites: Number of local sites
:param ldim: Local ldimension
:param randstate: numpy.random.RandomState instance or None
:returns: numpy.ndarray of shape (ldim, ldim) * sites

>>> from numpy.linalg import eigvalsh
>>> rho = _random_state(3, 2).reshape((2**3, 2**3))
>>> all(eigvalsh(rho) >= 0)
True
>>> np.abs(np.trace(rho) - 1) < 1e-6
True
"""
shape = (ldim**sites, ldim**sites)
mat = _zrandn(shape, randstate=randstate)
rho = np.conj(mat.T).dot(mat)
rho /= np.trace(rho)
return rho.reshape((ldim,) * 2 * sites)

####################################
#  Factory functions for MPArrays  #
#################################### ```