Philox(seed=None, counter=None, key=None)Lock instance that is shared so that the same bit git generator can be used in multiple Generators without corrupting the state. Code that generates values from a bit generator should hold the bit generator's lock.
Philox is a 64-bit PRNG that uses a counter-based design based on weaker (and faster) versions of cryptographic functions . Instances using different values of the key produce independent sequences. Philox has a period of $2^{256} - 1$ and supports arbitrary advancing and jumping the sequence in increments of $2^{128}$ . These features allow multiple non-overlapping sequences to be generated.
Philox
provides a capsule containing function pointers that produce doubles, and unsigned 32 and 64- bit integers. These are not directly consumable in Python and must be consumed by a Generator
or similar object that supports low-level access.
State and Seeding
The Philox
state vector consists of a 256-bit value encoded as a 4-element uint64 array and a 128-bit value encoded as a 2-element uint64 array. The former is a counter which is incremented by 1 for every 4 64-bit randoms produced. The second is a key which determined the sequence produced. Using different keys produces independent sequences.
The input seed
is processed by SeedSequence
to generate the key. The counter is set to 0.
Alternately, one can omit the seed
parameter and set the key
and counter
directly.
Parallel Features
The preferred way to use a BitGenerator in parallel applications is to use the SeedSequence.spawn
method to obtain entropy values, and to use these to generate new BitGenerators:
>>> from numpy.random import Generator, Philox, SeedSequence >>> sg = SeedSequence(1234) >>> rg = [Generator(Philox(s)) for s in sg.spawn(10)]
Philox
can be used in parallel applications by calling the jumped
method to advances the state as-if $2^{128}$
random numbers have been generated. Alternatively, advance
can be used to advance the counter for any positive step in [0, 2**256). When using jumped
, all generators should be chained to ensure that the segments come from the same sequence.
>>> from numpy.random import Generator, Philox >>> bit_generator = Philox(1234) >>> rg = [] >>> for _ in range(10): ... rg.append(Generator(bit_generator)) ... bit_generator = bit_generator.jumped()
Alternatively, Philox
can be used in parallel applications by using a sequence of distinct keys where each instance uses different key.
>>> key = 2**96 + 2**33 + 2**17 + 2**9 >>> rg = [Generator(Philox(key=key+i)) for i in range(10)]
Compatibility Guarantee
Philox
makes a guarantee that a fixed seed
will always produce the same random integer stream.
A seed to initialize the BitGenerator
. If None, then fresh, unpredictable entropy will be pulled from the OS. If an int
or array_like[ints]
is passed, then it will be passed to SeedSequence
to derive the initial BitGenerator
state. One may also pass in a SeedSequence
instance.
Counter to use in the Philox state. Can be either a Python int (long in 2.x) in [0, 2**256) or a 4-element uint64 array. If not provided, the RNG is initialized at 0.
Key to use in the Philox state. Unlike seed
, the value in key is directly set. Can be either a Python int in [0, 2**128) or a 2-element uint64 array. :None:None:`key` and seed
cannot both be used.
Container for the Philox (4x64) pseudo-random number generator.
>>> from numpy.random import Generator, PhiloxSee :
... rg = Generator(Philox(1234))
... rg.standard_normal() 0.123 # random
Hover to see nodes names; edges to Self not shown, Caped at 50 nodes.
Using a canvas is more power efficient and can get hundred of nodes ; but does not allow hyperlinks; , arrows or text (beyond on hover)
SVG is more flexible but power hungry; and does not scale well to 50 + nodes.
All aboves nodes referred to, (or are referred from) current nodes; Edges from Self to other have been omitted (or all nodes would be connected to the central node "self" which is not useful). Nodes are colored by the library they belong to, and scaled with the number of references pointing them