J'essaie de créer une matrice de nombres aléatoires, mais ma solution est trop longue et a l'air moche

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

cela semble correct, mais dans ma mise en œuvre, c'est

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

qui est extrêmement illisible et ne tient pas sur une seule ligne.

Jetez un œil à numpy.random.rand :

Chaîne de documents: rand (d0, d1, ..., dn)

Valeurs aléatoires dans une forme donnée.

Créez un tableau de la forme donnée et propagez-le avec des échantillons aléatoires à partir d'une distribution 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 ]])

Vous pouvez déposer le range(len()):

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

Mais vraiment, vous devriez probablement utiliser 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]])

utiliser np.random.randint()tel numpy.random.random_integers()quel

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

Il semble que vous exécutiez une implémentation Python de l'exercice Coursera Machine Learning Neural Network. Voici ce que j'ai fait pour 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

Tout d'abord, créez un numpytableau puis convertissez-le en matrix. Voir le code ci-dessous:

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)

Pour des nombres aléatoires sur 10. Pour sur 20, nous devons multiplier par 20.

Lorsque vous dites "une matrice de nombres aléatoires", vous pouvez utiliser numpy comme Pavel https://stackoverflow.com/a/15451997/6169225 mentionné ci-dessus, dans ce cas, je suppose que la distribution de ces derniers (pseudo ) les nombres aléatoires adhèrent.

Cependant, si vous avez besoin d'une distribution particulière (j'imagine que vous êtes intéressé par la distribution uniforme), numpy.randoma des méthodes très utiles pour vous. Par exemple, disons que vous voulez une matrice 3x2 avec une distribution uniforme pseudo aléatoire limitée par [faible, élevé]. Vous pouvez faire ceci comme ceci:

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

Notez que vous pouvez remplacer uniformpar n'importe quel nombre de distributions prises en charge par cette bibliothèque.

Lectures complémentaires: https://docs.scipy.org/doc/numpy/reference/routines.random.html

Un moyen simple de créer un tableau d'entiers aléatoires est:

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

Ce qui suit génère une matrice 2 par 3 d'entiers aléatoires de 0 à 10:

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

Pour créer un tableau de nombres aléatoires, NumPy permet de créer un tableau en utilisant:

1. Nombres réels

2. Entiers

Pour créer un tableau en utilisant des nombres réels aléatoires : il y a 2 options

1. random.rand (pour une distribution uniforme des nombres aléatoires générés)
2. random.randn (pour la distribution normale des nombres aléatoires générés)

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) 

Pour créer un tableau en utilisant des nombres entiers aléatoires :

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

où

• low = le plus petit entier (signé) à tirer de la distribution
• high (optionnel) = Si fourni, un au-dessus du plus grand entier (signé) à tirer de la distribution
• size (facultatif) = Forme de sortie c'est-à-dire si la forme donnée est, par exemple, (m, n, k), alors m * n * k échantillons sont dessinés
• dtype (facultatif) = dtype souhaité du résultat.

par exemple:

L'exemple donné produira un tableau d'entiers aléatoires entre 0 et 4, sa taille sera 5 * 5 et aura 25 entiers

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

afin de créer une matrice 5 sur 5, elle doit être modifiée en

arr2 = np.random.randint (0,5, size = (5,5)), changez le symbole de multiplication * en virgule, #

[[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'exemple donné produira un tableau d'entiers aléatoires entre 0 et 1, sa taille sera 1 * 10 et aura 10 entiers

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]

Une réponse utilisant 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 (ligne, colonne) génère des nombres aléatoires entre 0 et 1, selon les paramètres spécifiés (m, n) donnés. Utilisez-le donc pour créer une matrice (m, n) et multipliez la matrice pour la limite de plage et additionnez-la à la limite supérieure.

Analyse: Si zéro est généré, seule la limite basse sera maintenue, mais si une est générée, seule la limite haute sera maintenue. En d'autres termes, en générant les limites à l'aide de rand numpy, vous pouvez générer les nombres extrêmes souhaités.

import numpy as np

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

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

Production:

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