Inferência Estatística

Treinamento de Probabilidade e Inferência Estatística (31/08/2022)

Parte 2: Inferência Estatística

Inferência Estatística: o processo de tirar conclusões sobre informações populacionais (ou seja, informações da variável aleatória XX) a partir de uma amostra da população.

Imagine um cenário prático real. Suponha que estamos interessados em estimar a altura média da população brasileira. Poderíamos dar um jeito de registrar todos os mais de 200 milhões de habitantes em um super censo custoso e complexo. Entretanto, muitas vezes o valor exato não nos importa tanto, uma aproximação suficientemente boa já nos basta, entendendo o erro associado à nossa afirmação. Em outros casos, isso é simplesmente inviável.

Um exemplo de inferência é selecionar alguns indivíduos brasileiros e tirar a média dessa subpopulação (amostra).

Código da célula
# X1
Código da célula
plt.hist(X1)
plt.show()
Gráfico da célula
Código da célula
X1.mean().round(4)
1.7298

Amostragem

Mas como garantir que a distribuição da variável na nossa amostra é significativamente parecida com a distribuição da variável na população geral? Existem várias técnicas clássicas de amostragem que tentam garantir isso:

  • Amostragem Aleatória Simples

Todos os elementos da população têm uma chance igual de serem selecionados.

  • Amostragem Estratificada

A distribuição de uma variável conhecida é mantida na amostra.

Na teoria de probabilidade, a ideia é pensar que cada uma das variáveis observadas é a observação de uma variável aleatória que tem distribuição igual à distribuição da população original. Quando tiramos uma amostra, estamos avaliando essas variáveis aleatórias.

Definição (amostra aleatória): Dizemos que o conjunto das variáveis aleatórias X1X_1, ⋯\cdots, XnX_n é uma amostra aleatória de XX de tamanho nn se as variáveis são independentes e identicamente distribuídas com distribuição igual à da variável aleatória XX. Ela pode ser denotada pelo vetor aleatório X~=(X1,⋯ ,Xn)\tilde{X}=(X_1, \cdots,X_n).

Modelo estatístico (paramétrico)

Um modelo estatístico é definido por uma família de probabilidades X\mathcal{X} que possivelmente descrevem o comportamento probabilístico dos dados.

Na prática, estamos assumindo que X∈XX\in \mathcal{X}. Ou seja, estamos restringindo o comportamento da variável aleatória para um subconjunto de possíveis variáveis aleatórias. Em particular, na estatística paramétrica, estamos supondo que a distribuição de XX pode ser parametrizada por algum argumento θ∈Θ⊂Rn\theta\in\Theta\subset \mathbb{R}^n. Isto é, podemos escrever X∼fθX\sim f_\theta para definir unicamente os elementos de X\mathcal{X}, portanto, podemos escrever X={X∼fθ:θ∈Θ}\mathcal{X} = \{X\sim f_\theta : \theta\in\Theta\}.

Neste caso, qualquer quantidade de interesse da população é escrita como g(θ)g(\theta).

Estamos fazendo perguntas sobre um atributo populacional que não podemos medir diretamente. Mas podemos medir na nossa amostra observada.

Definição (amostra observada): São os valores efetivamente observados após executar o experimento. A amostra observada costuma ser denotada pela letra minúscula correspondente à da variável aleatória.

x~=(x1,⋯ ,xn). \tilde{x} = (x_1,\cdots,x_n).

Função de verossimilhança da amostra

Definição (função de verossimilhança): Seja X~=(X1,⋯ ,Xn)\tilde{X}=(X_1,\cdots,X_n) uma amostra aleatória de X∼fθX\sim f_{\theta}, θ∈Θ\theta \in \Theta. A função de verossimilhança é a função (densidade) de probabilidade calculada no x~\tilde{x} observado. Neste caso, θ\theta é o argumento.

Lx~(θ)=fθ(x~)=Πi=1nfθ(xi), \mathscr{L}_{\tilde{x}}(\theta) = f_\theta(\tilde{x}) = \Pi_{i=1}^n f_\theta(x_i) ,

ou

Lx~(θ)=Pθ(X~=x~)=Πi=1nPθ(Xi=xi). \mathscr{L}_{\tilde{x}}(\theta) = P_\theta(\tilde{X} = \tilde{x}) = \Pi_{i=1}^n P_\theta(X_i = x_i) .

Notação alternativa: L(θ ;x~)\mathscr{L}(\theta\,; \tilde{x})

Lembrando que a amostra aleatória implica em independência. Por isso, podemos quebrar Lx~\mathscr{L}_{\tilde{x}} na multiplicação.

Exemplo: Suponha que nosso modelo estatístico seja da forma

Xθ∼fθ(x)=12π exp⁡(−(x−θ)22),   θ∈(−1,1)⊂R. X_\theta \sim f_\theta(x) = \frac{1}{\sqrt{2\pi}} \,\exp\left({-\frac{(x-\theta)^2}{2}} \right),\,\,\, \theta\in(-1,1)\subset\mathbb{R}.

Vamos calcular a função de verossimilhança para uma amostra observada x~=\tilde{x}=X2.

Código da célula
theta = np.random.RandomState(42).uniform(-1, 1)
X2 = np.random.RandomState(42).normal(theta, 1, size=400)
Código da célula
# X2
Código da célula
def densidade_normal(theta, x):
    return 1/(np.sqrt(2*np.pi))*np.exp(-(x-theta)**2/2)
Código da célula
densidade_normal(0, 0)
0.3989422804014327
Código da célula
def verossimilhanca(theta, vetor_x, densidade):
    aux = 1
    for x in vetor_x:
        aux *= densidade(theta, x)
    return aux
Código da célula
valores_theta = np.linspace(-1, 1, 1000)
ver = verossimilhanca(valores_theta, X2, densidade_normal)

plt.plot(valores_theta, ver)
plt.show()
Gráfico da célula
Código da célula
theta
-0.250919762305275

Estimadores e estimativas

Definição (estatística): Uma estatística é uma função da amostra aleatória.

Em que denoto a função indicadora tal que 1(True)=1\mathbb{1}(\textrm{True})=1 e 1(False)=0\mathbb{1}(\textrm{False})=0.

Definição (estimador pontual): Um estimador é uma estatística cujo objetivo é estimar uma quantidade g(θ)g(\theta).

É esperado que a imagem do estimador esteja contida em g(Θ)={g(θ):θ∈Θ}g(\Theta) = \{ g(\theta) : \theta \in \Theta \}.

Definição (estimativa): Uma estimativa é o valor numérico de um estimador que foi calculado usando a amostra observada.

Uma parte da estatística está interessada em construir estimadores com propriedades boas! Uma das técnicas é utilizar o método de máxima verossimilhança.

Viés e variância de um estimador

O viés de um estimador T(X~)T(\tilde{X}) com objetivo de calcular uma quantidade de interesse g(θ)g(\theta) é

Vieˊsθ(T(X~))=Eθ(T(X~)−g(θ)). \textrm{Viés}_\theta(T(\tilde{X})) = \mathbb{E}_\theta\left(T(\tilde{X}) - g(\theta) \right).

A sua variância é explicitamente Varθ(T(X~))\textrm{Var}_\theta(T(\tilde{X})).

É de interesse ter estimadores não viciados (ou não viesados), ou seja, estimadores com viés 0. Além disso, esperamos ter variância baixa.

O ENVVUM (estimador não viesado com variância uniformemente mínima) é um estimador não viesado que tem, dado outro estimador não viciado, variância menor que a dele.

∮\oint Existe um valor mínimo que a variância de um estimador não viesado pode ter. Esse valor é chamado de limite inferior de Cramér–Rao e está relacionada com a informação de Fisher.

Existem várias técnicas interessantes para construir estimadores, como o método de momentos, o método de mínimos quadrados, o teorema de Lehmann-Scheffé etc. Vamos comentar sobre um dos mais clássicos, o estimador de máxima verossimilhança.

Máxima verossimilhança

Neste método, encontramos o θ\theta que melhor adapta x~\tilde{x} aos dados observados, aos olhos da verossimilhança Lx~(θ)\mathscr{L}_{\tilde{x}}(\theta). Isto é, o valor que maximiza essa quantidade. Denotamos o θ\theta estimado por θ^MV\widehat{\theta}_{MV}. Além disso, é possível calcular a estimativa de máxima verossimilhança de g(θ)g(\theta) como g(θ^MV)g(\widehat{\theta}_{MV}), pela invariância do estimador de máxima verossimilhança.

Para achar o argumento θ\theta que maximiza Lx~(θ)\mathscr{L}_{\tilde{x}}(\theta), podemos usar várias estratégias de maximização.

Usualmente, achamos a raiz da equação

ddθLx~(θ)=0. \frac{d}{d\theta} \mathscr{L}_{\tilde{x}}(\theta) = 0 .

Nem sempre isso é trivial e, computacionalmente, podemos ter problemas de underflow (já que Lx~\mathscr{L}_{\tilde{x}} é a multiplicação de vários valores menores do que 1). Como Lx~(θ)≥0\mathscr{L}_{\tilde{x}}(\theta)\geq 0, já que é uma função densidade de probabilidade, podemos aplicar a função log⁡(⋅)\log(\cdot) (uma função monótona) e maximizar

log⁡(Lx~(θ))=∑i=1nlog⁡(fθ(xi)). \log\left( \mathscr{L}_{\tilde{x}}(\theta) \right)= \sum_{i=1}^n \log\left( f_\theta(x_i) \right) .

Em outros casos pode ser preciso usar métodos numéricos para achar a raiz dessa equação.

Exemplo: Suponha que estamos analisando o tempo de ligações de uma determinada empresa. Por algum motivo, é razoável querer entender qual a probabilidade de as ligações demorarem entre 4 e 5 minutos.

Recebemos a seguinte amostra aleatória de 20 elementos de tempo de ligações:

Código da célula
X3 = np.array([0.202, 5.3267, 0.8842, 1.8331, 0.5744, 0.1402,
               5.119, 3.1183, 5.569, 0.7165, 0.365, 0.2521,
               1.5503, 1.2344, 3.6096, 0.3423, 5.0797,
               7.9643, 0.2668, 3.3204])
Código da célula
plt.hist(X3)
plt.show()
Gráfico da célula

Código da célula
(X3>4) & (X3<5)
array([False, False, False, False, False, False, False, False, False,
       False, False, False, False, False, False, False, False, False,
       False, False])
Código da célula
((X3>4) & (X3<5)).sum()
0

Podemos supor que os dados fazem parte de uma distribuição exponencial, ou seja, que X∼Exp(θ)X\sim \textrm{Exp}(\theta) para θ∈(0,∞)\theta\in (0,\infty). A partir disso podemos estimar θ\theta e calcular uma estimativa para g(θ)g(\theta).

Código da célula
def densidade_exponencial(theta, x):
    return theta*np.exp(-theta*x)
Código da célula
valores_theta = np.linspace(0,2,1000)
ver = verossimilhanca(valores_theta, X3, densidade_exponencial)

plt.plot(valores_theta, ver)
plt.vlines(valores_theta[np.argmax(ver)],np.min(ver),verossimilhanca(valores_theta[np.argmax(ver)], X3, densidade_exponencial))
plt.show()
Gráfico da célula
Código da célula
valores_theta[np.argmax(ver)]
0.42042042042042044
Código da célula
plt.hist(X3, density=True)
plt.plot(np.linspace(0,10), densidade_exponencial(valores_theta[np.argmax(ver)], np.linspace(0,10)))
plt.show()
Gráfico da célula
Código da célula
np.exp(-4*valores_theta[np.argmax(ver)])-np.exp(-5*valores_theta[np.argmax(ver)])
0.06386153502253891

Intervalos de confiança

Tudo bem, achamos uma estimativa pontual para nossa quantidade desejada g(θ)g(\theta). Sabemos que provavelmente esse não é o valor perfeito. Nossa estimativa depende da amostra que coletamos e existe uma aleatoriedade que nos diz que ela pode variar cada vez que realizamos o experimento. Em muitos casos, conseguimos estimar essas variações e calcular intervalos de confiança que nos permitem acreditar que nossa quantidade desejada real está em um certo intervalo com alta probabilidade.

A partir desses intervalos, podemos construir testes de hipótese validando se nossas estimativas pontuais são razoáveis.

Código da célula
theta = 3
np.random.RandomState(42).normal(theta, 1, size=50).mean()
2.7745260947438597
Código da célula
media_amostra = \
np.array(
    [np.random.RandomState(i).normal(theta, 1, size=50).mean() for i in range(10000)]
)

plt.hist(media_amostra)
plt.show()
Gráfico da célula
Código da célula
((media_amostra > 2.72) & (media_amostra<3.28)).sum()/10000
0.9519

Quantidade pivotal

Na prática, construir intervalos de confiança (teóricos ou aproximados) é uma tarefa difícil. Precisamos ter muita confiança no modelo estatístico que estamos usando (ou seja, precisamos definir bem X\mathcal{X}), além de saber construir uma quantidade pivotal.

Definição (quantidade pivotal): Dizemos que M(g(θ),X~)M(g(\theta), \tilde{X}) é uma quantidade pivotal (exata) para g(θ)g(\theta) se a sua distribuição não depende de θ\theta.

Uma função é dita quantidade pivotal aproximada para g(θ)g(\theta) quando, no limite de n→∞n\to\infty, sua distribuição não depende de θ\theta.

Exemplo: Seja X~=(X1,⋯ ,Xn)\tilde{X}=(X_1, \cdots, X_n) amostra aleatória de X∼N(θ,1)X\sim \mathcal{N}(\theta, 1), θ∈R\theta\in\mathbb{R}. Então as funções

M1(θ,X~)=X1−θ, M_1(\theta, \tilde{X}) = X_1 - \theta ,M2(θ,X~)=n(∑i=1nXin−θ), M_2(\theta, \tilde{X}) = \sqrt{n}\left(\frac{\sum_{i=1}^n X_i}{n}-\theta \right),

são exemplos de quantidades pivotais, já que tanto M1(θ,X~)M_1(\theta, \tilde{X}) quanto M2(θ,X~)M_2(\theta, \tilde{X}) têm distribuição N(0,1)\mathcal{N}(0,1) (que não depende de θ\theta).

Construindo um intervalo de confiança

Não vou entrar em detalhes, mas a partir de uma quantidade pivotal é possível construir um intervalo de confiança (com nível de confiança γ∈(0,1)\gamma\in(0,1)). Basta existir c1γc_1^\gamma e c2γc_2^\gamma que satisfaçam a equação

P(c1γ≤M(g(θ),X~)≤c2γ)=γ, \mathbb{P}\left( c_1^\gamma \leq M(g(\theta), \tilde{X}) \leq c_2^\gamma \right) = \gamma,

e estatísticas t1γ(X~)t_1^\gamma(\tilde{X}) e t2γ(X~)t_2^\gamma(\tilde{X}) tais que

c1γ≤M(g(θ),X~)≤c2γ⇔t1γ(X~)≤g(θ)≤t2γ(X~). c_1^\gamma \leq M(g(\theta), \tilde{X}) \leq c_2^\gamma \Leftrightarrow t_1^\gamma(\tilde{X}) \leq g(\theta) \leq t_2^\gamma(\tilde{X}).

Neste caso temos o intervalo de confiança teórico:

IC(g(θ),γ)=[t1γ(X~),t2γ(X~)]∩g(Θ). IC(g(\theta), \gamma) = [t_1^\gamma(\tilde{X}), t_2^\gamma(\tilde{X})] \cap g(\Theta).

Quando temos uma amostra observada x~\tilde{x} de X~\tilde{X}, então obtemos o intervalo de confiança observado:

ICobs(g(θ),γ)=[t1γ(x~),t2γ(x~)]∩g(Θ). IC_{obs}(g(\theta), \gamma) = [t_1^\gamma(\tilde{x}), t_2^\gamma(\tilde{x})] \cap g(\Theta).

Intervalos de confiança com bootstrap

O bootstrap se baseia na primeira ideia que fizemos para construir o intervalo de confiança: repetir o experimento uma quantidade significativa de vezes para não ter apenas uma estimativa pontual, mas um conjunto grande de estimativas.

Mas como construir amostras diferentes do mesmo experimento quando só temos uma amostra? A ideia é amostrar com repetição. Amostras com repetição de um determinado conjunto vão manter aproximadamente a distribuição inicial:

Código da célula
amostra_inicial = np.random.RandomState(42).normal(theta, 1, size=500)
Código da célula
amostra_reposicao = np.random.RandomState(42).choice(amostra_inicial, replace=True, size=500)

fig, ax = plt.subplots(ncols=2, figsize=(10, 4))
_, bins, _ = ax[0].hist(amostra_inicial, density=True, label='histograma da amostra observada')
ax[0].hist(amostra_reposicao, bins=bins, alpha = 0.7, density=True, label='histograma da amostra de bootstrap')
x_ = np.linspace(-1, 7, 1000)
ax[0].plot(x_, scipy.stats.norm(loc=3, scale=1).pdf(x=x_), 'k', label='fdp real')

ax[1].hist(amostra_inicial, density=True)
for i in range(7):
    amostra_reposicao_for = np.random.RandomState(i).choice(amostra_inicial, replace=True, size=500)
    ax[1].hist(amostra_reposicao_for, bins=bins, alpha = 0.7, density=True)
ax[1].plot(x_, scipy.stats.norm(loc=3, scale=1).pdf(x=x_), 'k')

ax[0].set_ylim(0, 0.55)
ax[1].set_ylim(0, 0.55)
ax[0].legend()
plt.tight_layout()
Gráfico da célula

Repare que todas as amostras que conseguimos por bootstrap seguem de maneira aproximada a distribuição da amostra observada, que, por sua vez, segue aproximadamente a distribuição real da variável aleatória.

Código da célula
bootstraps = [np.random.RandomState(i).choice(amostra_inicial, replace=True, size=500).mean() for i in range(10000)]

A partir dessa amostra podemos fazer inferência sobre a quantidade de interesse (no nosso caso, o próprio θ\theta) pegando estatísticas relevantes como os percentis/quantis.

∮\oint: A função quantil (ou percentil) qX:(0,1)→Rq_X:(0,1)\to\mathbb{R} é tal que P(X≤qX(α))=α. \mathbb{P}(X\leq q_X(\alpha)) = \alpha.

(Na prática é um pouco mais chato que isso... Veja mais sobre a função quantil no meu blog - shameless self promotion).

Código da célula
np.percentile(bootstraps, q=[2.5, 97.5])
array([2.91989873, 3.09353478])

Neste caso, estamos pegando os valores que fazem com que 95% das nossas médias calculadas por bootstrap estejam limitados por eles. Diríamos que o intervalo de confiança de nível de confiança 95% é [2.92,3.09][2.92, 3.09], que inclui o verdadeiro valor de θ\theta.

Mais sobre inferência não paramétrica

Nem sempre será possível escolher X\mathcal{X} de maneira comportada (por vezes, você não vai querer fazer isso) sendo parametrizada por um parâmetro, como comentamos. Ainda assim, podemos estar interessados em fazer inferências sobre a nossa amostra.

Existe uma grande família de métodos para tentar lidar com esse problema. Inclusive o bootstrap é um deles. Outro que vale a pena ser mencionado é o Kernel Density Estimation (KDE), que é uma técnica bem simples de fazer uma aproximação da função densidade de probabilidade utilizando uma amostra observada.

Não vou dar muitos detalhes, mas a ideia é dar peso para as regiões ao redor da nossa amostra e ter como aproximação para a função densidade de probabilidade a média das funções menores. Um dos kernels usados, nesse caso, é colocar funções gaussianas ao redor de cada um dos seus exemplos, o seaborn.histplot faz isso quando você passa o parâmetro kde=True.

Código da célula
fig, ax = plt.subplots(ncols=2, figsize=(10, 4))
seaborn.histplot(amostra_inicial, ax=ax[0], kde=True)
seaborn.histplot(np.random.RandomState(42).exponential(size=1000), ax=ax[1], kde=True)
plt.show()
Gráfico da célula

∮\oint No kernel gaussiano, temos uma dependência muito grande no valor de σ\sigma que escolhemos para as gaussianas que colocamos ao redor dos pontos. Não é trivial escolher a melhor, mas você pode fazer um holdout dos seus dados para depois calcular a verossimilhança da amostra reservada com cada uma das escolhas de σ\sigma e ver qual tem melhor valor! ;)

Esse vídeo sobre o KDE é muito didático e útil.