Sto cercando di creare una matrice di numeri casuali, ma la mia soluzione è troppo lunga e sembra brutta

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

sembra ok, ma nella mia implementazione lo è

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

che è estremamente illeggibile e non si adatta a una riga.

Dai un'occhiata a numpy.random.rand :

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

Valori casuali in una data forma.

Crea un array della forma data e propagalo con campioni casuali da una distribuzione uniforme [0, 1).

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

Puoi eliminare range(len()):

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

Ma in realtà, dovresti probabilmente usare numpy.

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]])

utilizzare np.random.randint()come numpy.random.random_integers()è deprecato

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

Sembra che tu stia eseguendo un'implementazione Python dell'esercizio Coursera Machine Learning Neural Network. Ecco cosa ho fatto per randInitializeWeights (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

Innanzitutto, crea un numpyarray, quindi convertilo in matrix. Vedi il codice qui sotto:

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)

Per numeri casuali su 10. Per 20 dobbiamo moltiplicare per 20.

Quando dici "una matrice di numeri casuali", puoi usare numpy come Pavel https://stackoverflow.com/a/15451997/6169225 menzionato sopra, in questo caso presumo che per te sia irrilevante quale distribuzione questi (pseudo ) numeri casuali rispettano.

Tuttavia, se hai bisogno di una distribuzione particolare (immagino che tu sia interessato alla distribuzione uniforme), numpy.randomha metodi molto utili per te. Ad esempio, supponiamo che tu voglia una matrice 3x2 con una distribuzione uniforme pseudo casuale delimitata da [basso, alto]. Puoi farlo in questo modo:

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

Nota, puoi sostituire uniformcon qualsiasi numero di distribuzioni supportate da questa libreria.

Ulteriori letture: https://docs.scipy.org/doc/numpy/reference/routines.random.html

Un modo semplice per creare un array di numeri interi casuali è:

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

Quanto segue restituisce una matrice 2 per 3 di numeri interi casuali da 0 a 10:

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

Per creare un array di numeri casuali, NumPy fornisce la creazione di array utilizzando:

1. Numeri reali

2. Interi

Per creare un array utilizzando numeri reali casuali : ci sono 2 opzioni

1. random.rand (per la distribuzione uniforme dei numeri casuali generati)
2. random.randn (per la distribuzione normale dei numeri casuali generati)

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) 

Per creare un array utilizzando numeri interi casuali :

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

dove

• low = numero intero più basso (con segno) da estrarre dalla distribuzione
• high (opzionale) = Se fornito, uno sopra il più grande numero intero (con segno) da estrarre dalla distribuzione
• size (opzionale) = Forma di output, ovvero se la forma data è, ad esempio, (m, n, k), vengono disegnati m * n * k campioni
• dtype (opzionale) = dtype desiderato del risultato.

per esempio:

L'esempio fornito produrrà un array di numeri interi casuali tra 0 e 4, la sua dimensione sarà 5 * 5 e avrà 25 numeri interi

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

per creare una matrice 5 per 5, è necessario modificarla in

arr2 = np.random.randint (0,5, size = (5,5)), cambia il simbolo di moltiplicazione * in una virgola, #

[[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:

L'esempio fornito produrrà un array di numeri interi casuali tra 0 e 1, la sua dimensione sarà 1 * 10 e avrà 10 numeri interi

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]

Una risposta usando 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 (riga, colonna) genera numeri casuali compresi tra 0 e 1, in base ai parametri specificati (m, n). Quindi usalo per creare una matrice (m, n) e moltiplica la matrice per il limite dell'intervallo e sommala con il limite alto.

Analisi: se viene generato zero, verrà mantenuto solo il limite inferiore, ma se ne viene generato uno verrà mantenuto solo il limite superiore. In altre parole, generando i limiti usando rand numpy puoi generare i numeri estremi desiderati.

import numpy as np

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

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

Produzione:

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