scipy.sparse.

random_array#

scipy.sparse.random_array(shape, *, density=0.01, format='coo', dtype=None, rng=None, data_sampler=None)[Quelle]#

Gibt ein Sparse-Array mit gleichmäßig zufälligen Zahlen in [0, 1) zurück

Gibt ein Sparse-Array mit der angegebenen Form und Dichte zurück, wobei die Werte gleichmäßig zufällig im Bereich [0, 1) generiert werden.

Parameter:
shapeint oder Tupel von ints

Form des Arrays

densityreal, optional (Standard: 0.01)

Dichte der erzeugten Matrix: Eine Dichte von eins bedeutet eine volle Matrix, eine Dichte von 0 bedeutet eine Matrix ohne Nicht-Null-Elemente.

formatstr, optional (Standard: ‘coo’)

Format der dünnbesetzten Matrix.

dtypedtype, optional (Standard: np.float64)

Typ der Werte der zurückgegebenen Matrix.

rng{None, int, numpy.random.Generator}, optional

Wenn rng als Schlüsselwort übergeben wird, werden andere Typen als numpy.random.Generator an numpy.random.default_rng übergeben, um einen Generator zu instanziieren. Wenn rng bereits eine Generator-Instanz ist, dann wird die bereitgestellte Instanz verwendet. Geben Sie rng für reproduzierbares Funktionsverhalten an.

Wenn dieses Argument positional übergeben wird oder random_state als Schlüsselwort übergeben wird, gilt das ältere Verhalten für das Argument random_state.

  • Wenn random_state None ist (oder numpy.random), wird die Singleton-Instanz numpy.random.RandomState verwendet.

  • Wenn random_state eine Ganzzahl ist, wird eine neue RandomState-Instanz verwendet, die mit random_state initialisiert wurde.

  • Wenn random_state bereits eine Generator- oder RandomState-Instanz ist, wird diese Instanz verwendet.

Geändert in Version 1.15.0: Im Rahmen des SPEC-007-Übergangs von der Verwendung von numpy.random.RandomState zu numpy.random.Generator wurde dieser Schlüsselwortparameter von random_state zu rng geändert. Für einen Übergangszeitraum werden beide Schlüsselwortparameter weiterhin funktionieren, obwohl nur einer gleichzeitig angegeben werden kann. Nach der Übergangszeit werden Funktionsaufrufe, die den random_state-Schlüsselwortparameter verwenden, Warnungen ausgeben. Das Verhalten von sowohl random_state als auch rng ist oben beschrieben, aber nur der rng-Schlüsselwortparameter sollte in neuem Code verwendet werden.

Dieser Zufallszustand wird zum Stichprobenziehen von indices (der Sparsity-Struktur) und standardmäßig auch für die Datenwerte verwendet (siehe data_sampler).

data_samplercallable, optional (Standard hängt von dtype ab)

Sampler für zufällige Datenwerte mit dem Schlüsselwortargument size. Diese Funktion sollte ein einzelnes Schlüsselwortargument size entgegennehmen, das die Länge ihres zurückgegebenen ndarrays angibt. Sie wird verwendet, um die Nicht-Null-Werte in der Matrix zu generieren, nachdem deren Positionen gewählt wurden. Standardmäßig werden gleichmäßige [0, 1)-Zufallswerte verwendet, es sei denn, dtype ist ein Integer (standardmäßig gleichmäßige Integer dieses dtypes) oder komplex (standardmäßig gleichmäßig über dem Einheitsquadrat in der komplexen Ebene). Für diese wird der rng verwendet, z. B. rng.uniform(size=size).

Rückgabe:
resSparse-Array

Beispiele

Übergabe einer np.random.Generator-Instanz für bessere Leistung

>>> import numpy as np
>>> import scipy as sp
>>> rng = np.random.default_rng()

Standardmäßiges Stichprobenziehen gleichmäßig aus [0, 1)

>>> S = sp.sparse.random_array((3, 4), density=0.25, rng=rng)

Bereitstellen eines Samplers für die Werte

>>> rvs = sp.stats.poisson(25, loc=10).rvs
>>> S = sp.sparse.random_array((3, 4), density=0.25,
...                            rng=rng, data_sampler=rvs)
>>> S.toarray()
array([[ 36.,   0.,  33.,   0.],   # random
       [  0.,   0.,   0.,   0.],
       [  0.,   0.,  36.,   0.]])

Bereitstellen eines Samplers für uint-Werte

>>> def random_uint32_to_100(size=None):
...     return rng.integers(100, size=size, dtype=np.uint32)
>>> S = sp.sparse.random_array((3, 4), density=0.25, rng=rng,
...                            data_sampler=random_uint32_to_100)

Erstellen einer benutzerdefinierten Verteilung. Dieses Beispiel erstellt eine quadrierte Normalverteilung aus np.random

>>> def np_normal_squared(size=None, rng=rng):
...     return rng.standard_normal(size) ** 2
>>> S = sp.sparse.random_array((3, 4), density=0.25, rng=rng,
...                            data_sampler=np_normal_squared)

Oder wir können es aus sp.stats-Stil rvs-Funktionen erstellen

>>> def sp_stats_normal_squared(size=None, rng=rng):
...     std_normal = sp.stats.distributions.norm_gen().rvs
...     return std_normal(size=size, random_state=rng) ** 2
>>> S = sp.sparse.random_array((3, 4), density=0.25, rng=rng,
...                            data_sampler=sp_stats_normal_squared)

Oder wir können sp.stats rv_continuous oder rv_discrete unterklassifizieren

>>> class NormalSquared(sp.stats.rv_continuous):
...     def _rvs(self,  size=None, random_state=rng):
...         return rng.standard_normal(size) ** 2
>>> X = NormalSquared()
>>> Y = X().rvs
>>> S = sp.sparse.random_array((3, 4), density=0.25,
...                            rng=rng, data_sampler=Y)
Auf dieser Seite