Distribuzione che ha un intervallo da 0 a 1 e con un picco tra di loro?

Esiste una distribuzione o posso lavorare da un'altra distribuzione per creare una distribuzione come quella nell'immagine qui sotto (scuse per i cattivi disegni)?

dove do un numero (0,2, 0,5 e 0,9 negli esempi) per dove dovrebbe essere il picco e una deviazione standard (sigma) che rende la funzione più ampia o meno ampia.

PS: quando il numero dato è 0,5 la distribuzione è una distribuzione normale.

Una possibile scelta è la distribuzione beta , ma parametrizzata in termini di media e precisione $\mu$$\phi$ , ovvero "per fisso , maggiore è il valore di ϕ , minore è la varianza di y " (vedi Ferrari e Cribari- Neto, 2004). La funzione di densità di probabilità viene costruita sostituendo i parametri standard della distribuzione beta con α = ϕ μ e β = ϕ ( 1 - μ $\mu$$\phi$$y$$\alpha = \phi\mu$$\beta = \phi(1-\mu)$

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

In alternativa, è possibile calcolare i parametri e β appropriati che porterebbero alla distribuzione beta con media e varianza predefinite. Tuttavia, si noti che esistono restrizioni sui possibili valori di varianza validi per la distribuzione beta. Per me personalmente, la parametrizzazione usando la precisione è più intuitiva (pensate a $\alpha$$\beta$ proporzioni in X binomialmente distribuita, con dimensione del campione ϕ e probabilità di successo μ ).$x\,/\,\phi$ $X$$\phi$$\mu$

La distribuzione di Kumaraswamy è un'altra distribuzione continua limitata, ma sarebbe più difficile ri-parametrizzare come sopra.

Come altri hanno notato, è non è normale, poiché distribuzione normale ha il di supporto, così al meglio è possibile utilizzare il normale troncato come approssimazione.$(-\infty, \infty)$

_{Ferrari, S., e Cribari-Neto, F. (2004). Regressione beta per tassi e proporzioni di modellazione. Journal of Applied Statistics, 31 (7), 799-815.}

Prova la distribuzione beta, la sua gamma va da 0 a 1. Hai già provato questo? Il valore medio è $\frac{\alpha}{(\alpha + \beta)}$

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

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

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

$y$$x$$F()$

Se qualcuno è interessato alla soluzione che ho usato in Python per generare un valore casuale vicino al numero dato come parametro. La mia soluzione esiste in quattro fasi. Ogni fase è maggiore la possibilità che il numero generato sia più vicino al numero indicato.

So che la soluzione non è bella come usare una distribuzione, ma questo è stato il modo in cui sono stato in grado di risolvere il mio problema:

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()

risultato quando si esegue questo codice è mostrato nella figura seguente:

Potresti dare un'occhiata a "Johnson curve". Vedi NL Johnson: Sistemi di curve di frequenza generati dai metodi di traduzione. 1949 Biometrika Volume 36 pp 149-176. R ha il supporto per adattarli a curve arbitrarie. In particolare, le sue curve SB (limitate) potrebbero essere utili.

Sono passati 40 anni da quando li ho usati, ma in quel momento mi sono stati molto utili e penso che funzioneranno per te.