scipy.sparse.

random#

scipy.sparse.random(m, n, density=0.01, format='coo', dtype=None, rng=None, data_rvs=None)[Quelle]#

Erzeugt eine dünnbesetzte Matrix gegebener Form und Dichte mit zufällig verteilten Werten.

Warnung

Diese Funktion gibt eine dünnbesetzte Matrix zurück – keine dünnbesetzte Array. Sie werden ermutigt, random_array zu verwenden, um die Funktionalität dünnbesetzter Arrays zu nutzen.

Parameter:
m, nint

Form der Matrix

densityreal, optional

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

Format der dünnbesetzten Matrix.

dtypedtype, optional

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: Als Teil des SPEC-007-Übergangs von der Verwendung von numpy.random.RandomState zu numpy.random.Generator wurde dieses Schlüsselwort von random_state zu rng geändert. Für eine Übergangszeit werden beide Schlüsselwörter weiterhin funktionieren, obwohl nur eines gleichzeitig angegeben werden darf. Nach der Übergangszeit werden Funktionsaufrufe mit dem Schlüsselwort random_state Warnungen ausgeben. Das Verhalten von sowohl random_state als auch rng ist oben umrissen, aber nur das Schlüsselwort rng sollte in neuem Code verwendet werden.

Dieser Zufallszustand wird für die Stichprobenentnahme der Sparsity-Struktur verwendet, aber nicht unbedingt für die Stichprobenentnahme der Werte der strukturell Nicht-Null-Einträge der Matrix.

data_rvscallable, optional

Nimmt eine angeforderte Anzahl von Zufallswerten. Diese Funktion sollte ein einzelnes Argument nehmen, das die Länge des von ihr zurückgegebenen ndarray angibt. Die strukturell Nicht-Null-Einträge der dünnbesetzten Zufallsmatrix werden aus dem von dieser Funktion entnommenen Array übernommen. Standardmäßig werden gleichmäßige Zufallswerte im Bereich [0, 1) unter Verwendung desselben Zufallszustands wie für die Stichprobenentnahme der Sparsity-Struktur entnommen.

Rückgabe:
resdünnbesetzte Matrix

Siehe auch

random_array

konstruiert dünnbesetzte Arrays anstelle von dünnbesetzten Matrizen

Beispiele

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

>>> import scipy as sp
>>> import numpy as np
>>> rng = np.random.default_rng()
>>> S = sp.sparse.random(3, 4, density=0.25, rng=rng)

Bereitstellung eines Samplers für die Werte

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

Erstellung 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(3, 4, density=0.25, rng=rng,
...                      data_rvs=np_normal_squared)

Oder wir können sie aus sp.stats-Style 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(3, 4, density=0.25, rng=rng,
...                      data_rvs=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()  # get a frozen version of the distribution
>>> S = sp.sparse.random(3, 4, density=0.25, rng=rng, data_rvs=Y.rvs)
Auf dieser Seite