Hello,

Sous Maya je query la couleur d'une map (mais seulement la luminance), j'obtiens une valeur entre 0 (noir) et 1 (blanc). J'aimerai que cette même valeur (que j’appellerai "ON") m'en renvoie une autre : soit 0, soit 1.

Le truc c'est que sur la luminance j'obtiens parfois 0.2, ou 0.5, ou encore 0.8, etc. Bref j'aimerai que la valeur ON soit influencée en fonction de ces valeurs là. Par exemple : si ma luminance est égale à 0.3, alors j'ai 30% de chance que la valeur ON soit égale à 1, et logiquement 70% de chance que sa valeur soit égale à 0. De même pour 0.9, 90% de chance que ce soit égale à 1, 10% à 0, etc.

Mais le truc c'est que je ne vois pas comment m'y prendre en Python. Je présume que c'est assez simple finalement. Je suis pas un gros matheux, donc j'ai beau chercher...

Un grand merci pour votre aide !

random.random() -> x in the interval [0, 1)

« uniformément » normalement.

Du coup tu as juste à valoir 1 si tu es dans une partie de longueur ON de [0,1[, on va prendre [0, ON[ (mais tu peux très bien prendre ]1-ON, 1[ si ça te chante, ou [ON/2, 1-ON/2] ou [0, ON/2] ∪ [1-ON/2, 1[ …):

import random
def sample(p):
  if random.random() < p:
    return 1
  else:
    return 0

(le else étant facultatif, tu peux juste mettre « return 0 » désindenté d’un niveau.)

In [3]: [ sample(0.3) for _ in range(20) ]
Out[3]: [1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]

Merci pour ta réponse.

Je comprends pas très bien toute cette partie en fait :

"Du coup tu as juste à valoir 1 si tu es dans une partie de longueur ON de [0,1[, on va prendre [0, ON[ (mais tu peux très bien prendre ]1-ON, 1[ si ça te chante, ou [ON/2, 1-ON/2] ou [0, ON/2] ∪ [1-ON/2, 1[ …):"

Dans le premier bout de code que tu écris est-ce que la valeur influe sur le random ? Je veux dire si dans ma fonction sample je lui donne 0.9 j'aurais pas forcément plus de chance d'avoir une valeur supérieur à 0.9 que si je lui donne 0.2 par exemple, non ? Etant donné que c'est complètement random. Il faut que "p" influe sur ce random en fait. Ou alors j'ai mal compris... ?

Merci

Arrrg arrrg, n'écrit pas uniformément et normalement comme ça l'un à coté de l'autre Dark, c'est perturbant !

Ahah, j’avais pas pensé à normale dans ce sens

Lewul Mettons que tu aies une fonction qui te renvoie une valeur uniformément aléatoire entre 0 et 1, appelons la u.
Si je dis 1 pour une valeur < 0.5 et 0 sinon. Ça signifie que si en tirant mon réel u, je peux tomber n’importe où sur [0,1[ avec autant de chance, en particulier je peux tomber avant la moitié de l’intervalle avec proba ½ et au delà avec proba ½.

Maintenant l’idée de sample c’est d’étendre naturellement ce constat, au lieu de regarder si j’arrive avant la première moitié ou non, je regarde si j’arrive avant le premier p% ou non, ce qui arrive avec proba p%.

Si tu ne vois pas, tu peux faire le dessin de l’intervalle [0,1[ et dessus placer le segment [0,p].

bluepoint_ : c'est pas grand chose c'est juste que dans un script j'ai besoin de ça. Après je pense pas pouvoir en parler plus, enfin c'est mieux je présume.

Dark_Chouhartem : oui mais là en l’occurrence avec 0.5 j'ai forcément une chance sur deux, mais si je veux vraiment influer sur mon random, par exemple si je prend 0.95, alors j'ai trèèèès peu de chance d'avoir une valeur de 0. Mais comment je fais du coup ? Ou alors je te suis pas, désolé j'avoue ne pas être une brute en script

Ahhh, c’est pas du script, c’est de la p****n de proba.

Tu as un dé à 6 faces, tu renvoies 1 si tu as moins de 4, 0 sinon, alors dans ce cas, tu as 1 avec proba 4/6 = 2/3 et 0 avec proba 1/3…

Maintenant à la place d’un dé qui te renvoie 1,2,…,6, tu as un dé qui te renvoie un réel entre 0 et 1.

Et si t’es pas convaincu:

In [3]: [ sample(0.9) for _ in range(20) ]
Out[3]: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1]

In [4]: [ sample(0.1) for _ in range(20) ]
Out[4]: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]

(mais c’est pas un bon argument l’exemple)

Sinon tu le fais en algo.

Boucle x10 pour des pourcentages finissant par 0 ( ici on prendre 20% de chances pour 0 et 80% pr 1 ).
tu random(0 ou 1), t'additionne le tout par ex ca fait 5. Donc 5 est supérieur à 20% donc t'es dans l'autre tranche tu met 1.
Pour des pourcentages genre 33% faire une boucle x100 et aménagé les if d'après.

J'ai jamais testé ça, je viens d'y penser mais ça me parait bon.

NICOLOMBIANO Non, là tu as une loi binomiale.
Et pour voir que ça ne fonctionne pas, il suffit de regarder pour 10% avec X ta variable aléatoire représentant la valeur de la somme des tirages aléatoires fait par ton programme:
Pr[ X = 1 ] = 10 * 1/2 * 1/2^9≃ 1%
C’est assez loin de tes 10%

Pour t’en rendre compte :

In [2]: Counter([ sum(random.randrange(0,2) for _ in range(10)) for _ in range(1000)])
Out[2]: Counter({5: 265, 6: 211, 4: 179, 3: 139, 7: 104, 2: 45, 8: 42, 1: 8, 9: 5, 10: 2})

C’est pas réparti très équitablement…

Ok autant pour moi

NICOLOMBIANO Mais si tu veux vraiment te faire chier, tu peux le faire, l’idée est de récupérer la décomposition binaire de ta proba p = Σ_i a_i 2^(-i), par exemple 0.5 = b0.1, 0.625 = b0.101, d’en récupérer les 1 et ensuite de vérifier si un événement de { 0^{i-1}1x | a_i = 1 } arrive (avec x quelconque)

Ce sont des événements disjoints (si on a 1xx on ne peut pas avoir 001 par exemple, puisque ça contredirait le fait que le premier bit de 001 est à 0), et chacun arrive avec probabilité 1/2^k… oh miracle en faisant la somme des probabilités (puisque événements disjoints), on réobtient bien p.

Du coup un algo pour y arriver consiste à tirer des bits aléatoires, de regarder la position du premier 1. Si elle correspond à un 1 dans la décomposition binaire de p, alors c’est bon, on a gagné, sinon on a perdu.

Voilà une implé possible:

import random

def sample(p) :
    i = 1
    while True:
        bit = random.randrange(2)
        if bit == 1:
            if (int( 2**i * p) & 1) == 1 :
                return 1
            else:
                return 0
        else:
            i += 1

Hey,

Je suis con c'était logique le coup du random tout simple en fait... Bref ça marche du coup

Merci beaucoup !