Ich versuche eine Matrix von Zufallszahlen zu erstellen, aber meine Lösung ist zu lang und sieht hässlich aus

random_matrix = [[random.random() for e in range(2)] for e in range(3)]

Das sieht in Ordnung aus, ist es aber in meiner Implementierung

weights_h = [[random.random() for e in range(len(inputs[0]))] for e in range(hiden_neurons)]

Das ist extrem unlesbar und passt nicht in eine Zeile.

Schauen Sie sich numpy.random.rand an :

Docstring: Rand (d0, d1, ..., dn)

Zufällige Werte in einer bestimmten Form.

Erstellen Sie ein Array der angegebenen Form und verbreiten Sie es mit zufälligen Stichproben aus einer gleichmäßigen Verteilung über [0, 1).

>>> import numpy as np
>>> np.random.rand(2,3)
array([[ 0.22568268,  0.0053246 ,  0.41282024],
       [ 0.68824936,  0.68086462,  0.6854153 ]])

Sie können Folgendes löschen range(len()):

weights_h = [[random.random() for e in inputs[0]] for e in range(hiden_neurons)]

Aber wirklich, Sie sollten wahrscheinlich numpy verwenden.

In [9]: numpy.random.random((3, 3))
Out[9]:
array([[ 0.37052381,  0.03463207,  0.10669077],
       [ 0.05862909,  0.8515325 ,  0.79809676],
       [ 0.43203632,  0.54633635,  0.09076408]])

Verwenden Sie np.random.randint()wie numpy.random.random_integers()veraltet

random_matrix = numpy.random.randint(min_val,max_val,(<num_rows>,<num_cols>))

Sieht so aus, als würden Sie eine Python-Implementierung der Übung Coursera Machine Learning Neural Network durchführen. Folgendes habe ich für randInitializeWeights getan (L_in, L_out)

#get a random array of floats between 0 and 1 as Pavel mentioned 
W = numpy.random.random((L_out, L_in +1))

#normalize so that it spans a range of twice epsilon
W = W * 2 * epsilon

#shift so that mean is at zero
W = W - epsilon

Erstellen Sie zuerst ein numpyArray und konvertieren Sie es dann in matrix. Siehe den folgenden Code:

import numpy

B = numpy.random.random((3, 4)) #its ndArray
C = numpy.matrix(B)# it is matrix
print(type(B))
print(type(C)) 
print(C)

x = np.int_(np.random.rand(10) * 10)

Für Zufallszahlen von 10. Für von 20 müssen wir mit 20 multiplizieren.

Wenn Sie "eine Matrix von Zufallszahlen" sagen, können Sie numpy als Pavel https://stackoverflow.com/a/15451997/6169225 verwenden , in diesem Fall gehe ich davon aus, dass es für Sie irrelevant ist, welche Verteilung diese (Pseudo) ) Zufallszahlen halten sich an.

Wenn Sie jedoch eine bestimmte Verteilung benötigen (ich glaube, Sie interessieren sich für die gleichmäßige Verteilung), stehen numpy.randomIhnen sehr nützliche Methoden zur Verfügung. Angenommen, Sie möchten eine 3x2-Matrix mit einer pseudozufälligen Gleichverteilung, die durch [niedrig, hoch] begrenzt ist. Sie können dies folgendermaßen tun:

numpy.random.uniform(low,high,(3,2))

Beachten Sie, dass Sie uniformdurch eine beliebige Anzahl von Distributionen ersetzen können, die von dieser Bibliothek unterstützt werden.

Weiterführende Literatur: https://docs.scipy.org/doc/numpy/reference/routines.random.html

Eine einfache Möglichkeit, ein Array von zufälligen Ganzzahlen zu erstellen, ist:

matrix = np.random.randint(maxVal, size=(rows, columns))

Im Folgenden wird eine 2 x 3-Matrix zufälliger Ganzzahlen von 0 bis 10 ausgegeben:

a = np.random.randint(10, size=(2,3))

Zum Erstellen eines Arrays von Zufallszahlen bietet NumPy die Erstellung von Arrays mit:

1. Reale Nummern

2. Ganzzahlen

Zum Erstellen eines Arrays mit zufälligen reellen Zahlen gibt es zwei Möglichkeiten

1. random.rand (zur gleichmäßigen Verteilung der generierten Zufallszahlen)
2. random.randn (zur Normalverteilung der generierten Zufallszahlen)

random.rand

import numpy as np 
arr = np.random.rand(row_size, column_size) 

random.randn

import numpy as np 
arr = np.random.randn(row_size, column_size) 

Zum Erstellen eines Arrays mit zufälligen Ganzzahlen:

import numpy as np
numpy.random.randint(low, high=None, size=None, dtype='l')

wo

• low = Niedrigste (vorzeichenbehaftete) Ganzzahl, die aus der Verteilung gezogen werden soll
• high (optional) = Falls angegeben, eine über der größten (vorzeichenbehafteten) Ganzzahl, die aus der Verteilung gezogen werden soll
• Größe (optional) = Ausgabeform, dh wenn die angegebene Form z. B. (m, n, k) ist, werden m * n * k Proben gezogen
• dtype (optional) = Gewünschter dtype des Ergebnisses.

z.B:

Das gegebene Beispiel erzeugt ein Array von zufälligen ganzen Zahlen zwischen 0 und 4, seine Größe ist 5 * 5 und hat 25 ganze Zahlen

arr2 = np.random.randint(0,5,size = (5,5))

Um eine 5 x 5-Matrix zu erstellen, sollte diese in geändert werden

arr2 = np.random.randint (0,5, size = (5,5)), ändern Sie das Multiplikationssymbol * in ein Komma, #

[[2 1 1 0 1] [3 2 1 4 3] [2 3 0 3 3] [1 3 1 0 0] [4 1 2 0 1]]

eg2:

Das gegebene Beispiel erzeugt ein Array von zufälligen ganzen Zahlen zwischen 0 und 1, seine Größe ist 1 * 10 und hat 10 ganze Zahlen

arr3= np.random.randint(2, size = 10)

[0 0 0 0 1 1 0 0 1 1]

random_matrix = [[random.random for j in range(collumns)] for i in range(rows)
for i in range(rows):
    print random_matrix[i]

Eine Antwort mit Map-Reduce: -

map(lambda x: map(lambda y: ran(),range(len(inputs[0]))),range(hiden_neurons))

#this is a function for a square matrix so on the while loop rows does not have to be less than cols.
#you can make your own condition. But if you want your a square matrix, use this code.

import random

import numpy as np

def random_matrix(R, cols):

        matrix = []

        rows =  0

        while  rows < cols:

            N = random.sample(R, cols)

            matrix.append(N)

            rows = rows + 1

    return np.array(matrix)

print(random_matrix(range(10), 5))
#make sure you understand the function random.sample

numpy.random.rand (Zeile, Spalte) generiert Zufallszahlen zwischen 0 und 1 gemäß den angegebenen (m, n) Parametern. Verwenden Sie es also, um eine (m, n) Matrix zu erstellen und die Matrix für die Bereichsgrenze zu multiplizieren und mit der oberen Grenze zu summieren.

Analysieren: Wenn Null generiert wird, wird nur die Untergrenze gehalten, aber wenn Eins generiert wird, wird nur die Obergrenze gehalten. In Ordnungswörtern können Sie durch Generieren der Grenzwerte mit rand numpy die extrem gewünschten Zahlen generieren.

import numpy as np

high = 10
low = 5
m,n = 2,2

a = (high - low)*np.random.rand(m,n) + low

Ausgabe:

a = array([[5.91580065, 8.1117106 ],
          [6.30986984, 5.720437  ]])