Estou tentando criar uma matriz de números aleatórios, mas minha solução é muito longa e parece feia

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

isso parece ok, mas na minha implementação é

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

que é extremamente ilegível e não cabe em uma linha.

Dê uma olhada em numpy.random.rand :

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

Valores aleatórios em uma determinada forma.

Crie um array da forma dada e propague-o com amostras aleatórias de uma distribuição 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 ]])

Você pode abandonar range(len()):

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

Mas, realmente, você provavelmente deve usar 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]])

usar np.random.randint()como numpy.random.random_integers()está obsoleto

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

Parece que você está fazendo uma implementação em Python do exercício Coursera Machine Learning Neural Network. Aqui está o que fiz para 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

Primeiro, crie o numpyarray e depois converta-o em matrix. Veja o código abaixo:

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)

Para números aleatórios de 10. Para de 20, temos que multiplicar por 20.

Quando você diz "uma matriz de números aleatórios", você pode usar numpy como Pavel https://stackoverflow.com/a/15451997/6169225 mencionado acima, neste caso estou assumindo para você que é irrelevante a distribuição desses (pseudo ) os números aleatórios aderem.

Porém, se você necessita de uma distribuição particular (imagino que esteja interessado na distribuição uniforme), numpy.randompossui métodos muito úteis para você. Por exemplo, digamos que você queira uma matriz 3x2 com uma distribuição uniforme pseudoaleatória limitada por [baixo, alto]. Você pode fazer isso assim:

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

Observe que você pode substituir uniformpor qualquer número de distribuições suportadas por esta biblioteca.

Leitura adicional: https://docs.scipy.org/doc/numpy/reference/routines.random.html

Uma maneira simples de criar uma matriz de inteiros aleatórios é:

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

O seguinte resulta em uma matriz 2 por 3 de inteiros aleatórios de 0 a 10:

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

Para criar uma matriz de números aleatórios, o NumPy fornece a criação de uma matriz usando:

1. Numeros reais

2. Inteiros

Para criar uma matriz usando números reais aleatórios : há 2 opções

1. random.rand (para distribuição uniforme dos números aleatórios gerados)
2. random.randn (para distribuição normal dos números aleatórios gerados)

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) 

Para criar uma matriz usando números inteiros aleatórios :

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

Onde

• baixo = Inteiro mais baixo (com sinal) a ser extraído da distribuição
• alto (opcional) = Se fornecido, um acima do maior número inteiro (com sinal) a ser extraído da distribuição
• tamanho (opcional) = Forma de saída, ou seja, se a forma fornecida é, por exemplo, (m, n, k), então m * n * k amostras são desenhadas
• dtype (opcional) = dtipo desejado do resultado.

por exemplo:

O exemplo dado irá produzir uma matriz de inteiros aleatórios entre 0 e 4, seu tamanho será 5 * 5 e terá 25 inteiros

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

a fim de criar uma matriz 5 por 5, ela deve ser modificada para

arr2 = np.random.randint (0,5, size = (5,5)), mude o símbolo de multiplicação * para uma vírgula, #

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

O exemplo dado irá produzir uma matriz de inteiros aleatórios entre 0 e 1, seu tamanho será 1 * 10 e terá 10 inteiros

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]

Uma resposta usando mapa-reduzir: -

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 (linha, coluna) gera números aleatórios entre 0 e 1, de acordo com os parâmetros especificados (m, n) dados. Portanto, use-o para criar uma matriz (m, n) e multiplique a matriz para o limite da faixa e some-a com o limite superior.

Analisando: Se zero for gerado, apenas o limite inferior será mantido, mas se um for gerado, apenas o limite superior será mantido. Em outras palavras, gerando os limites usando rand numpy, você pode gerar os números extremos desejados.

import numpy as np

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

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

Resultado:

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