J'ai un tableau 5 sur 10 et je veux retourner un peu si un nombre aléatoire est supérieur à 0,9. Cependant, cela ne fonctionne que pour la première ligne du tableau et n'atteint pas la deuxième ligne et les suivantes. J'ai remplacé les bits par 3 et 4 pour que je puisse facilement voir si le retournement se produit. J'ai obtenu des résultats qui ressemblent à ceci.

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

S'il vous plaît, aidez-moi à comprendre où je me trompe.


from random import random
RM =  np.random.randint(0,2, size=(5,10))
print(RM)
for k in range(0, RM.shape[0]):
    for j in range(0, RM.shape[1]):
        A  = random()
        if A > 0.9:
            if RM[k,j] == 0:
                np.put(RM, [k,j], [3]) 
                print("k1",k)
                print("j1", j)
            else:
                np.put(RM, [k,j], [4])  
                print("k2", k)
        else: 
            continue

print(RM)
1
KoKo 30 mai 2020 à 13:01

3 réponses

Consulter la documentation de np.put

numpy.put(a, ind, v, mode='raise')[source]
Replaces specified elements of an array with given values.

Sous Exemples:

a = np.arange(5)
np.put(a, [0, 2], [-44, -55])
a
array([-44,   1, -55,   3,   4])

Ainsi, si vous alimentez une liste à la fonction, elle remplace plusieurs valeurs dans le tableau aplati.

Pour que votre boucle fonctionne, il suffit d'assigner les valeurs au tableau:

from random import random
RM =  np.random.randint(0,2, size=(5,10))
print(RM)
for k in range(0, RM.shape[0]):
    for j in range(0, RM.shape[1]):
        A  = random()
        if A > 0.9:
            if RM[k,j] == 0:
                RM[k,j]=3 
                print("k1",k)
                print("j1", j)
            else:
                RM[k,j] =4  
                print("k2", k)
        else: 
            continue
1
warped 30 mai 2020 à 10:47

Pour parcourir un tableau Numpy , un outil pratique (et recommandé) est nditer .

Si vous souhaitez modifier les valeurs du tableau itéré, op_flags = ['readwrite'] devrait être adopté.

Pour avoir accès aux index de l'élément courant, en cas de Le tableau multidimensionnel , flags = ['multi_index'] doit être transmis.

Ci-dessous, vous avez un exemple de code, qui imprime également des indices dans chaque cas où l'élément actuel a été retourné.

Pour vérifier son fonctionnement, j'ai ajouté une impression de RM , les deux avant et après la boucle.

np.random.seed(0)
RM = np.random.randint(0, 2, size=(5, 10))
print('Before:')
print(RM, '\n')
with np.nditer(RM, op_flags=['readwrite'], flags=['multi_index']) as it:
    for x in it:
        A  = np.random.random()
        if A > 0.9:
            x[...] = 1 - x  # Flip
            print(f'Flip: <{it.multi_index}>,  {A:.3f}')
print('\nAfter:')
print(RM)

Pour obtenir un résultat reproductible, j'ai ajouté np.random.seed(0) (supprimez-le dans le version cible).

Avec l'ensemencement ci-dessus, j'ai obtenu le résultat suivant:

Before:
[[0 1 1 0 1 1 1 1 1 1]
 [1 0 0 1 0 0 0 0 0 1]
 [0 1 1 0 0 1 1 1 1 0]
 [1 0 1 0 1 1 0 1 1 0]
 [0 1 0 1 1 1 1 1 0 1]] 

Flip: <(0, 2)>,  0.945
Flip: <(1, 3)>,  0.944
Flip: <(2, 7)>,  0.988
Flip: <(4, 5)>,  0.976
Flip: <(4, 7)>,  0.977

After:
[[0 1 0 0 1 1 1 1 1 1]
 [1 0 0 0 0 0 0 0 0 1]
 [0 1 1 0 0 1 1 0 1 0]
 [1 0 1 0 1 1 0 1 1 0]
 [0 1 0 1 1 0 1 0 0 1]]

Comparez les éléments indiqués comme retournés, dans les sections «Avant» et «Après», pour confirmer que le code ci-dessus fait son travail. Vérifiez également qu'aucun autre élément n'a été modifié.

Un élément un peu délicat dans le code ci-dessus est x[...] = 1 - x. Notez que la partie 1 - x lit la valeur actuelle (jusqu'ici c'est OK). Mais si vous avez tenté de sauvegarder quelque chose dans x , en écrivant x =, alors vous rompriez le lien vers l'élément du tableau source. Dans ce cas, x pointerait vers la nouvelle valeur, mais pas vers le élément de tableau actuel.

Donc, pour ne pas rompre ce lien, il suffit de la notation x[...] =.

0
Valdi_Bo 30 mai 2020 à 11:47

Vous n'avez probablement pas besoin de l'itération. Les flips sont indépendants, vous pouvez générer les probabilités d'un seul coup, et simplement retourner:

np.random.seed(100)
RM =  np.random.randint(0,2, size=(5,10))

array([[0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
       [0, 1, 0, 0, 0, 0, 1, 0, 0, 1],
       [0, 1, 0, 0, 0, 1, 1, 1, 0, 0],
       [1, 0, 0, 1, 1, 1, 1, 1, 0, 0],
       [1, 1, 1, 1, 1, 1, 1, 1, 0, 1]])

alpha = np.random.uniform(0,1,(5,10))
np.round(alpha,2)

array([[0.49, 0.4 , 0.35, 0.5 , 0.45, 0.09, 0.27, 0.94, 0.03, 0.04],
       [0.28, 0.58, 0.99, 0.99, 0.99, 0.11, 0.66, 0.52, 0.17, 0.94],
       [0.24, 1.  , 0.58, 0.18, 0.39, 0.19, 0.41, 0.59, 0.72, 0.49],
       [0.31, 0.58, 0.44, 0.36, 0.32, 0.21, 0.45, 0.49, 0.9 , 0.73],
       [0.77, 0.38, 0.34, 0.66, 0.71, 0.11, 0.13, 0.46, 0.16, 0.96]])

RM[alpha>0.9] = abs(1-RM[alpha>0.9])
RM

array([[0, 0, 1, 1, 1, 1, 0, 1, 0, 0],
       [0, 1, 1, 1, 1, 0, 1, 0, 0, 0],
       [0, 0, 0, 0, 0, 1, 1, 1, 0, 0],
       [1, 0, 0, 1, 1, 1, 1, 1, 0, 0],
       [1, 1, 1, 1, 1, 1, 1, 1, 0, 0]])
1
StupidWolf 30 mai 2020 à 10:13