Distribuição que varia de 0 a 1 e com pico entre eles?

Existe uma distribuição ou posso trabalhar com outra distribuição para criar uma distribuição como essa na imagem abaixo (desculpas pelos desenhos ruins)?

onde eu forneço um número (0,2, 0,5 e 0,9 nos exemplos) para onde deve estar o pico e um desvio padrão (sigma) que torna a função mais ampla ou menos ampla.

PS: Quando o número fornecido é 0,5, a distribuição é normal.

Uma opção possível é a distribuição beta , mas parametrizada em termos de média e precisão ϕ , ou seja, "para μ fixo , quanto maior o valor de ϕ , menor a variação de y " (ver Ferrari e Cribari- Neto, 2004). A função densidade de probabilidade é construída substituindo os parâmetros padrão da distribuição beta por α = ϕ μ e β = ϕ ( 1 - μ $\mu$$\phi$$\mu$$\phi$$y$$\alpha = \phi\mu$$\beta = \phi(1-\mu)$

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

Como alternativa, você pode calcular parâmetros e β apropriados que levariam à distribuição beta com média e variância predefinidas. No entanto, observe que existem restrições sobre possíveis valores de variação válidos para a distribuição beta. Para mim, pessoalmente, a parametrização usando precisão é mais intuitiva (pense em $\alpha$$\beta$ proporções em X binomialmente distribuído, com tamanho de amostra ϕ e probabilidade de sucesso μ ).$x\,/\,\phi$ $X$$\phi$$\mu$

A distribuição Kumaraswamy é outra distribuição contínua limitada, mas seria mais difícil parametrizar como acima.

Como outros já perceberam, isso não é normal, pois a distribuição normal tem o suporte ; portanto, na melhor das hipóteses, você pode usar o normal truncado como uma aproximação.$(-\infty, \infty)$

_{Ferrari, S. & Cribari-Neto, F. (2004). Regressão beta para modelagem de taxas e proporções. Jornal de Estatística Aplicada, 31 (7), 799-815.}

Experimente a distribuição beta, seu intervalo é de 0 a 1. Você já tentou isso? O valor médio é $\frac{\alpha}{(\alpha + \beta)}$

Eu me transformei para criar esse tipo de variável. Comece com uma variável aleatória, x, que tem suporte em toda a linha real (como normal), e depois a transforme para criar uma nova variável aleatória . Presto, você tem uma variável aleatória distribuída no intervalo da unidade. Como essa transformação específica está aumentando, você pode mover a média / mediana / modo de y ao redor, movendo a média / mediana / modo de x ao redor. Deseja tornarymais disperso (em termos de alcance inter-quartil, por exemplo)? Apenas faça$y=\frac{exp(x)}{1+exp(x)}$$y$$x$ mais disperso.

Não há nada de especial na função $\frac{exp(x)}{1+exp(x)}$ . Qualquer função de distribuição cumulativa trabalha para produzir uma nova variável aleatória definida no intervalo da unidade.

$y=F(x)$$F()$$y$$F()$$x$$x$$y$$x$$y$ . Monotonicidade estrita é uma coisa agradável.

A fórmula para calcular a média e o sd de $y$talvez não seja fácil de encontrar, mas é para isso que servem as simulações de Monte Carlo. Para obter distribuições relativamente bonitas como as que você desenha, você quer$x$ e $F()$ ser variáveis ​​aleatórias contínuas (cdf de variáveis ​​aleatórias contínuas) com suporte na linha real.

Se alguém estiver interessado na solução que usei no Python para gerar um valor aleatório próximo ao número fornecido como parâmetro. Minha solução existe de quatro estágios. Cada estágio, a chance de o número gerado estar mais próximo do número especificado é maior.

Sei que a solução não é tão bonita quanto usar uma distribuição, mas foi assim que consegui resolver meu 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()

O resultado ao executar este código é mostrado na figura abaixo:

Você pode dar uma olhada nas 'Curvas de Johnson'. Veja NL Johnson: Sistemas de Curvas de Frequência gerados por métodos de tradução. 1949 Biometrika Volume 36 pp 149-176. R tem suporte para ajustá-los a curvas arbitrárias. Em particular, suas curvas SB (delimitadas) podem ser úteis.

Faz 40 anos desde que os usei, mas eles eram muito úteis para mim na época e acho que eles trabalharão para você.