Distribution qui a une plage de 0 à 1 et avec un pic entre eux?

Y a-t-il une distribution ou puis-je travailler à partir d'une autre distribution pour créer une distribution comme celle de l'image ci-dessous (excuses pour les mauvais dessins)?

où je donne un nombre (0,2, 0,5 et 0,9 dans les exemples) pour où le pic devrait être et un écart-type (sigma) qui rend la fonction plus ou moins large.

PS: Lorsque le nombre donné est 0,5, la distribution est une distribution normale.

Un choix possible est la distribution bêta , mais re-paramétrée en termes de moyenne et de précision ϕ , c'est-à-dire "pour μ fixe , plus la valeur de ϕ est grande , plus la variance de y est petite " (voir Ferrari et Cribari- Neto, 2004). La fonction de densité de probabilité est construite en remplaçant les paramètres standard de distribution bêta par α = ϕ μ et β = ϕ ( 1 - μ $\mu$$\phi$$\mu$$\phi$$y$$\alpha = \phi\mu$$\beta = \phi(1-\mu)$

où et V a r ( Y ) = μ ( 1 - $E(Y) = \mu$$\mathrm{Var}(Y) = \frac{\mu(1-\mu)}{1+\phi}$ .

Alternativement, vous pouvez calculer les et β appropriés$\alpha$$\beta$ paramètres qui conduiraient à une distribution bêta avec une moyenne et une variance prédéfinies. Cependant, notez qu'il existe des restrictions sur les valeurs possibles de variance valables pour la distribution bêta. Pour moi personnellement, le paramétrage à l'aide de la précision est plus intuitif (pensez à proportions dans X distribué binomialement, avec la taille de l'échantillon ϕ et la probabilité de succès$x\,/\,\phi$ $X$$\phi$$\mu$ ).

Distribution de kumaraswamy est une autre distribution continue bornée, mais il serait plus difficile de re-paramétrer comme ci-dessus.

Comme d'autres l'ont remarqué, ce n'est pas normal car la distribution normale a le support , donc au mieux vous pouvez utiliser la normale tronquée comme approximation.$(-\infty, \infty)$

_{Ferrari, S., et Cribari-Neto, F. (2004). Régression bêta pour la modélisation des taux et des proportions. Journal of Applied Statistics, 31 (7), 799-815.}

Essayez la distribution bêta, sa plage va de 0 à 1. Avez-vous déjà essayé cela? La valeur moyenne est $\frac{\alpha}{(\alpha + \beta)}$

$y=\frac{exp(x)}{1+exp(x)}$$y$$x$

La fonction n'a rien de spécial$\frac{exp(x)}{1+exp(x)}$

$y=F(x)$$F()$$y$$F()$$x$$x$$y$$x$$y$

$y$$x$$F()$

Si quelqu'un s'intéresse à la solution que j'ai utilisée en Python pour générer une valeur aléatoire proche du nombre donné comme paramètre. Ma solution existe en quatre étapes. À chaque étape, la chance que le nombre généré soit plus proche du nombre donné est plus grande.

Je sais que la solution n'est pas aussi belle que d'utiliser une seule distribution mais c'est ainsi que j'ai pu résoudre mon problème:

number_factory.py:

import random
import numpy as np

class NumberFactory:
    def __init__(self):
        self.functions = [self.__linear, self.__exponential_point_four, self.__exponential_point_three, self.__exponential_point_twenty_five]  
        self.stage = 0

    def next_stage(self):
        self.stage += 1

    def get_mutated_number(self, number):
         # True if the generated number will be higher than the given number
         # False if the generated number will be lower than the given number
        add = bool(np.random.choice([0,1], p=[number, 1-number]))

        # Generate a number between 0 and 1 that will be used
        # to multiply the new number by which the number parameter will be substracted or added
        # The bigger the stage number (0-3) the more change that the mutated number is close to the number parameter
        multiply_number_seed = random.uniform(0, 1)
        multiply_number = self.functions[self.stage](multiply_number_seed)

        if (add):
            return number+((1-number)*multiply_number)
        else:
            return number-(number*multiply_number)

    def __linear(self, x):
        return -x+1

    def __exponential_point_four(self, x):
        return 0.4*x**2 - 1.4*x + 1

    def __exponential_point_three(self, x):
        return 0.8*x**2 - 1.8*x + 1

    def __exponential_point_twenty_five(self, x):
        return x**2 - 2*x + 1

    def get_stage(self):
        return self.stage

main.py:

import matplotlib.pyplot as plt
import numpy as np

factory = NumberFactory()
numbers = []

factory.next_stage()
factory.next_stage()
factory.next_stage()

for _ in range(100000):
    numbers.append(factory.get_mutated_number(0.3))

bins = 100

plt.hist(numbers, bins, normed=True)
plt.plot(1, np.ones_like(bins))
plt.show()

résultat lors de l'exécution de ce code est illustré dans l'image ci-dessous:

Vous voudrez peut-être jeter un œil aux «courbes de Johnson». Voir NL Johnson: Systèmes de courbes de fréquence générées par des méthodes de traduction. 1949 Biometrika Volume 36 pp 149-176. R prend en charge leur adaptation à des courbes arbitraires. En particulier, ses courbes SB (délimitées) pourraient être utiles.

Cela fait 40 ans que je les utilise, mais ils m'ont été très utiles à l'époque, et je pense qu'ils fonctionneront pour vous.