The RandomState provides access to legacy generators. This generator is considered frozen and will have no further improvements. It is guaranteed to produce the same values as the final point release of NumPy v1.16. These all depend on Box-Muller normals or inverse CDF exponentials or gammas. This class should only be used if it is essential to have randoms that are identical to what would have been produced by previous versions of NumPy.
RandomState
RandomState adds additional information to the state which is required when using Box-Muller normals since these are produced in pairs. It is important to use RandomState.get_state, and not the underlying bit generators state, when accessing the state so that these extra values are saved.
RandomState.get_state
Although we provide the MT19937 BitGenerator for use independent of RandomState, note that its default seeding uses SeedSequence rather than the legacy seeding algorithm. RandomState will use the legacy seeding algorithm. The methods to use the legacy seeding algorithm are currently private as the main reason to use them is just to implement RandomState. However, one can reset the state of MT19937 using the state of the RandomState:
MT19937
SeedSequence
from numpy.random import MT19937 from numpy.random import RandomState rs = RandomState(12345) mt19937 = MT19937() mt19937.state = rs.get_state() rs2 = RandomState(mt19937) # Same output rs.standard_normal() rs2.standard_normal() rs.random() rs2.random() rs.standard_exponential() rs2.standard_exponential()
numpy.random.
Container for the slow Mersenne Twister pseudo-random number generator. Consider using a different BitGenerator with the Generator container instead.
RandomState and Generator expose a number of methods for generating random numbers drawn from a variety of probability distributions. In addition to the distribution-specific arguments, each method takes a keyword argument size that defaults to None. If size is None, then a single value is generated and returned. If size is an integer, then a 1-D array filled with generated values is returned. If size is a tuple, then an array with that shape is filled and returned.
Generator
None
Compatibility Guarantee
A fixed bit generator using a fixed seed and a fixed series of calls to ‘RandomState’ methods using the same parameters will always produce the same results up to roundoff error except when the values were incorrect. RandomState is effectively frozen and will only receive updates that are required by changes in the the internals of Numpy. More substantial changes, including algorithmic improvements, are reserved for Generator.
Random seed used to initialize the pseudo-random number generator or an instantized BitGenerator. If an integer or array, used as a seed for the MT19937 BitGenerator. Values can be any integer between 0 and 2**32 - 1 inclusive, an array (or other sequence) of such integers, or None (the default). If seed is None, then the MT19937 BitGenerator is initialized by reading data from /dev/urandom (or the Windows analogue) if available or seed from the clock otherwise.
seed
/dev/urandom
See also
numpy.random.BitGenerator
Notes
The Python stdlib module “random” also contains a Mersenne Twister pseudo-random number generator with a number of methods that are similar to the ones available in RandomState. RandomState, besides being NumPy-aware, has the advantage that it provides a much larger number of probability distributions to choose from.
get_state()
get_state
Return a tuple representing the internal state of the generator.
set_state(state)
set_state
Set the internal state of the generator from a tuple.
seed(self[, seed])
Reseed a legacy MT19937 BitGenerator
rand(d0, d1, …, dn)
rand
Random values in a given shape.
randn(d0, d1, …, dn)
randn
Return a sample (or samples) from the “standard normal” distribution.
randint(low[, high, size, dtype])
randint
Return random integers from low (inclusive) to high (exclusive).
random_integers(low[, high, size])
random_integers
Random integers of type np.int_ between low and high, inclusive.
random_sample([size])
random_sample
Return random floats in the half-open interval [0.0, 1.0).
choice(a[, size, replace, p])
choice
Generates a random sample from a given 1-D array
bytes(length)
bytes
Return random bytes.
shuffle(x)
shuffle
Modify a sequence in-place by shuffling its contents.
permutation(x)
permutation
Randomly permute a sequence, or return a permuted range.
beta(a, b[, size])
beta
Draw samples from a Beta distribution.
binomial(n, p[, size])
binomial
Draw samples from a binomial distribution.
chisquare(df[, size])
chisquare
Draw samples from a chi-square distribution.
dirichlet(alpha[, size])
dirichlet
Draw samples from the Dirichlet distribution.
exponential([scale, size])
exponential
Draw samples from an exponential distribution.
f(dfnum, dfden[, size])
f
Draw samples from an F distribution.
gamma(shape[, scale, size])
gamma
Draw samples from a Gamma distribution.
geometric(p[, size])
geometric
Draw samples from the geometric distribution.
gumbel([loc, scale, size])
gumbel
Draw samples from a Gumbel distribution.
hypergeometric(ngood, nbad, nsample[, size])
hypergeometric
Draw samples from a Hypergeometric distribution.
laplace([loc, scale, size])
laplace
Draw samples from the Laplace or double exponential distribution with specified location (or mean) and scale (decay).
logistic([loc, scale, size])
logistic
Draw samples from a logistic distribution.
lognormal([mean, sigma, size])
lognormal
Draw samples from a log-normal distribution.
logseries(p[, size])
logseries
Draw samples from a logarithmic series distribution.
multinomial(n, pvals[, size])
multinomial
Draw samples from a multinomial distribution.
multivariate_normal(mean, cov[, size, …])
multivariate_normal
Draw random samples from a multivariate normal distribution.
negative_binomial(n, p[, size])
negative_binomial
Draw samples from a negative binomial distribution.
noncentral_chisquare(df, nonc[, size])
noncentral_chisquare
Draw samples from a noncentral chi-square distribution.
noncentral_f(dfnum, dfden, nonc[, size])
noncentral_f
Draw samples from the noncentral F distribution.
normal([loc, scale, size])
normal
Draw random samples from a normal (Gaussian) distribution.
pareto(a[, size])
pareto
Draw samples from a Pareto II or Lomax distribution with specified shape.
poisson([lam, size])
poisson
Draw samples from a Poisson distribution.
power(a[, size])
power
Draws samples in [0, 1] from a power distribution with positive exponent a - 1.
rayleigh([scale, size])
rayleigh
Draw samples from a Rayleigh distribution.
standard_cauchy([size])
standard_cauchy
Draw samples from a standard Cauchy distribution with mode = 0.
standard_exponential([size])
standard_exponential
Draw samples from the standard exponential distribution.
standard_gamma(shape[, size])
standard_gamma
Draw samples from a standard Gamma distribution.
standard_normal([size])
standard_normal
Draw samples from a standard Normal distribution (mean=0, stdev=1).
standard_t(df[, size])
standard_t
Draw samples from a standard Student’s t distribution with df degrees of freedom.
triangular(left, mode, right[, size])
triangular
Draw samples from the triangular distribution over the interval [left, right].
[left, right]
uniform([low, high, size])
uniform
Draw samples from a uniform distribution.
vonmises(mu, kappa[, size])
vonmises
Draw samples from a von Mises distribution.
wald(mean, scale[, size])
wald
Draw samples from a Wald, or inverse Gaussian, distribution.
weibull(a[, size])
weibull
Draw samples from a Weibull distribution.
zipf(a[, size])
zipf
Draw samples from a Zipf distribution.
numpy.random
Many of the RandomState methods above are exported as functions in numpy.random This usage is discouraged, as it is implemented via a global RandomState instance which is not advised on two counts:
It uses global state, which means results will change as the code changes
It uses a RandomState rather than the more modern Generator.
For backward compatible legacy reasons, we cannot change this. See Quick Start.
random([size])
random
ranf
This is an alias of random_sample.
sample