Python numpy 模块，RandomState() 实例源码
我们从Python开源项目中，提取了以下12个代码示例，用于说明如何使用numpy.RandomState()。
def randomstate_constructor(value, name=None, strict=False,
allow_downcast=None, borrow=False):
"""
SharedVariable Constructor for RandomState.
"""
if not isinstance(value, numpy.random.RandomState):
raise TypeError
if not borrow:
value = copy.deepcopy(value)
return RandomStateSharedVariable(
type=raw_random.random_state_type,
value=value,
name=name,
strict=strict,
allow_downcast=allow_downcast)
def seed(self, seed=None):
"""
Re-initialize each random stream.
Parameters
----------
seed : None or integer in range 0 to 2**30
Each random stream will be assigned a unique state that depends
deterministically on this value.
Returns
-------
None
"""
if seed is None:
seed = self.default_instance_seed
seedgen = numpy.random.RandomState(seed)
for old_r, new_r in self.state_updates:
old_r_seed = seedgen.randint(2 ** 30)
old_r.set_value(numpy.random.RandomState(int(old_r_seed)),
borrow=True)
def __getitem__(self, item):
"""
Retrieve the numpy RandomState instance associated with a particular
stream.
Parameters
----------
item
A variable of type RandomStateType, associated
with this RandomStream.
Returns
-------
numpy RandomState (or None, before initialize)
Notes
-----
This is kept for compatibility with `tensor.randomstreams.RandomStreams`.
The simpler syntax ``item.rng.get_value()`` is also valid.
"""
return item.get_value(borrow=True)
def __setitem__(self, item, val):
"""
Set the numpy RandomState instance associated with a particular stream.
Parameters
----------
item
A variable of type RandomStateType, associated with this
RandomStream.
val : numpy RandomState
The new value.
Returns
-------
None
Notes
-----
This is kept for compatibility with `tensor.randomstreams.RandomStreams`.
The simpler syntax ``item.rng.set_value(val)`` is also valid.
"""
item.set_value(val, borrow=True)
def _smacof_single(dissimilarities, weights, init=None, anchors=None, n_components=2, maxitr=300, eps=1e-6, random_state=None):
# Pre-compute the weights of the Guttman transform
V = _gt_weights(weights)
if random_state is None:
random_state = np.random.RandomState()
# Initial positions are random by default
if init is None:
init = random_state.randn(dissimilarities.shape[0]-anchors.shape[0], n_components)
X = init
Sprev = _stress(dissimilarities, weights, np.vstack([X, anchors])) # Stress at previous iteration
for itr in range(maxitr):
X = _guttman_transform(dissimilarities, weights, X, anchors, V)
S = _stress(dissimilarities, weights, np.vstack([X, anchors]))
if np.abs(S - Sprev) < eps:
break
Sprev = S
return X, Sprev
def prepare_seed(*inputs, **kwinputs):
"""Update ``kwinputs`` with the seed from its value ``random_state``."""
if 'random_state' in kwinputs:
# Get the seed for this batch, assuming np.RandomState instance
seed = kwinputs['random_state'].get_state()[1][0]
# Since we may not be the first operation to use this seed, lets generate a
# a sub seed using this seed
sub_seed_index = kwinputs.get('index_in_batch') or 0
kwinputs['seed'] = get_sub_seed(seed, sub_seed_index)
return inputs, kwinputs
def __init__(self, fun, x0, bounds, seed=None, minimizer_kwargs=None,
temperature_start=5230, qv=2.62, qa=-5.0,
maxfun=1e7, maxsteps=500, pure_sa=False):
if x0 is not None and not len(x0) == len(bounds):
raise ValueError('Bounds size does not match x0')
lu = list(zip(*bounds))
lower = np.array(lu[0])
upper = np.array(lu[1])
# Checking that bounds are consistent
if not np.all(lower < upper):
raise ValueError('Bounds are note consistent min < max')
# Wrapper for the objective function and minimizer
if minimizer_kwargs is None:
minimizer_kwargs = dict()
self.owf = ObjectiveFunWrapper(bounds, fun, **minimizer_kwargs)
# Initialization of RandomState for reproducible runs if seed provided
self.rs = check_random_state(seed)
# Initialization of the energy state
self.es = EnergyState(lower, upper)
self.es.reset(self.owf, self.rs, x0)
# Maximum number of function call that can be used a stopping criterion
self.maxfun = maxfun
# Maximum number of step (main iteration) that can be used as
# stopping criterion
self.maxsteps = maxsteps
# Minimum value of annealing temperature reached to perform
# re-annealing
self.temperature_start = temperature_start
self.temperature_restart = 0.1
# VisitingDistribution instance
vd = VisitingDistribution(lower, upper, qv, self.rs)
# Markov chain instance
self.mc = MarkovChain(qa, vd, self.owf, self.rs, self.es)
self.qv = qv
self.pure_sa = pure_sa
def random_walks(n_ts=100, sz=256, d=1, mu=0., std=1., random_state=None):
"""Random walk time series generator.
Generate n_ts time series of size sz and dimensionality d.
Generated time series follow the model:
$$ts[t] = ts[t - 1] + a$$
where :math:`a` is drawn from a normal distribution of mean mu and standard deviation std.
Parameters
----------
n_ts : int (default: 100)
Number of time series.
sz : int (default: 256)
Length of time series (number of time instants).
d : int (default: 1)
Dimensionality of time series.
mu : float (default: 0.)
Mean of the normal distribution from which random walk steps are drawn.
std : float (default: 1.)
Standard deviation of the normal distribution from which random walk steps are drawn.
random_state : integer or numpy.RandomState or None (default: None)
Generator used to draw the time series. If an integer is given, it fixes the seed. Defaults to the global
numpy random number generator.
Returns
-------
numpy.ndarray
A dataset of random walk time series
Examples
--------
>>> random_walks(n_ts=100, sz=256, d=5, mu=0., std=1.).shape
(100, 256, 5)
"""
rs = check_random_state(random_state)
ts = numpy.empty((n_ts, sz, d))
rnd = rs.randn(n_ts, sz, d) * std + mu
ts[:, 0, :] = rnd[:, 0, :]
for t in range(1, sz):
ts[:, t, :] = ts[:, t - 1, :] + rnd[:, t, :]
return ts
def gamma_soft_dtw(dataset, n_samples=100, random_state=None):
"""Compute gamma value to be used for GAK/Soft-DTW.
This method was originally presented in [1]_.
Parameters
----------
dataset
A dataset of time series
n_samples : int (default: 100)
Number of samples on which median distance should be estimated
random_state : integer or numpy.RandomState or None (default: None)
The generator used to draw the samples. If an integer is given, it fixes the seed. Defaults to the global
numpy random number generator.
Returns
-------
float
Suggested :math:`\\gamma` parameter for the Soft-DTW
Example
-------
>>> dataset = [[1, 2, 2, 3], [1., 2., 3., 4.]]
>>> gamma_soft_dtw(dataset=dataset, n_samples=200, random_state=0) # doctest: +ELLIPSIS
8.0...
See Also
--------
sigma_gak : Compute sigma parameter for Global Alignment kernel
References
----------
.. [1] M. Cuturi, "Fast global alignment kernels," ICML 2011.
"""
return 2. * sigma_gak(dataset=dataset, n_samples=n_samples, random_state=random_state) ** 2
def __init__(self, seed=None):
super(RandomStreams, self).__init__()
# A list of pairs of the form (input_r, output_r). This will be
# over-ridden by the module instance to contain stream generators.
self.state_updates = []
# Instance variable should take None or integer value. Used to seed the
# random number generator that provides seeds for member streams.
self.default_instance_seed = seed
# numpy.RandomState instance that gen() uses to seed new streams.
self.gen_seedgen = numpy.random.RandomState(seed)
def random_walk_blobs(n_ts_per_blob=100, sz=256, d=1, n_blobs=2, noise_level=1., random_state=None):
"""Blob-based random walk time series generator.
Generate n_ts_per_blobs * n_blobs time series of size sz and dimensionality d.
Generated time series follow the model:
$$ts[t] = ts[t - 1] + a$$
where :math:`a` is drawn from a normal distribution of mean mu and standard deviation std.
Each blob contains time series derived from a same seed time series with added white noise.
Parameters
----------
n_ts_per_blob : int (default: 100)
Number of time series in each blob
sz : int (default: 256)
Length of time series (number of time instants)
d : int (default: 1)
Dimensionality of time series
n_blobs : int (default: 2)
Number of blobs
noise_level : float (default: 1.)
Standard deviation of white noise added to time series in each blob
random_state : integer or numpy.RandomState or None (default: None)
Generator used to draw the time series. If an integer is given, it fixes the seed. Defaults to the global
numpy random number generator.
Returns
-------
numpy.ndarray
A dataset of random walk time series
Examples
--------
>>> X, y = random_walk_blobs(n_ts_per_blob=100, sz=256, d=5, n_blobs=3)
>>> X.shape
(300, 256, 5)
>>> y.shape
(300,)
"""
rs = check_random_state(random_state)
base_ts = random_walks(n_ts=n_blobs, sz=sz, d=d, std=1.0, random_state=rs)
rnd = rs.randn(n_ts_per_blob * n_blobs, sz, d) * noise_level
ts = numpy.repeat(base_ts, repeats=n_ts_per_blob, axis=0)
y = numpy.repeat(range(n_blobs), repeats=n_ts_per_blob)
return ts + rnd, y
def sigma_gak(dataset, n_samples=100, random_state=None):
"""Compute sigma value to be used for GAK.
This method was originally presented in [1]_.
Parameters
----------
dataset
A dataset of time series
n_samples : int (default: 100)
Number of samples on which median distance should be estimated
random_state : integer or numpy.RandomState or None (default: None)
The generator used to draw the samples. If an integer is given, it fixes the seed. Defaults to the global
numpy random number generator.
Returns
-------
float
Suggested bandwidth (:math:`\\sigma`) for the Global Alignment kernel
Example
-------
>>> dataset = [[1, 2, 2, 3], [1., 2., 3., 4.]]
>>> sigma_gak(dataset=dataset, n_samples=200, random_state=0) # doctest: +ELLIPSIS
2.0...
See Also
--------
gak : Compute Global Alignment kernel
cdist_gak : Compute cross-similarity matrix using Global Alignment kernel
References
----------
.. [1] M. Cuturi, "Fast global alignment kernels," ICML 2011.
"""
random_state = check_random_state(random_state)
dataset = to_time_series_dataset(dataset)
n_ts, sz, d = dataset.shape
if n_ts * sz < n_samples:
replace = True
else:
replace = False
sample_indices = random_state.choice(n_ts * sz, size=n_samples, replace=replace)
dists = pdist(dataset.reshape((-1, d))[sample_indices], metric="euclidean")
return numpy.median(dists) * numpy.sqrt(sz)