Funções de Probabilidade em Algoritmos Estatísticos
Este artigo aborda funções essenciais de probabilidade para algoritmos estatísticos, incluindo cálculos de probabilidades marginais, conjuntas, condicionais, esperança, variância, covariância e aplicações financeiras em portfólios. As implementações em Python são apresentadas com exemplos adaptados.
Funções Auxiliares
Antes de explorar probabilidade, considere funções auxiliares para operações em conjuntos de dados, como soma, contagem, média, mediana, moda, variância, covariância e correlação. Estas são pré-requisitos para os cálculos de probabilidade.
- Probabilidade Marginal Simples
A probabilidade marginal simples denota a chance de um evento ocorrer isoladamente. Por exemplo, em um cenário com dois sacos de amendoins (saco A com 32 amendoins, 3 ruins; saco B com 17 amendoins, 5 ruins), a probabilidade marginal de pegar um amendoim ruim é calculada como o total de amendoins ruins dividido pelo total geral.
Definição: P(A) = número de eventos favoráveis / tamanho do espaço amostral. No exemplo, P(A) = 8/49 ≈ 0.1633.
- Probabilidade Conjunta
A probabilidade conjunta, P(A∩B), mede a probabilidade de dois eventos ocorrerem simultaneamente. No exemplo, considere o evento A como pegar um amendoim ruim e B como pegar do saco A. A probabilidade conjunta é dada pelo número de casos onde ambos ocorrem dividido pelo total.
Implementação em Python:
def calcular_probabilidade_conjunta(casos_favoraveis, total_casos):
prob = float(casos_favoraveis) / total_casos
return prob
No exemplo, P(A∩B) = 3/49 ≈ 0.0612.
- Probabilidade Condicional
A probabilidade condicional, P(A|B), é a probabilidade de um evento A dado que outro evento B ocorreu. A fórmula é P(A|B) = P(A∩B) / P(B). No exemplo, dado que se pegou do saco A, P(B) = 32/49, então P(A|B) = (3/49) / (32/49) = 3/32 ≈ 0.0937.
Implementação em Python:
def calcular_probabilidade_condicional(prob_conjunta, prob_b):
prob_condicional = prob_conjunta / prob_b
return prob_condicional
- Esperança de Variável Aleatória
A esperança ou valor esperado, E(X), é a média ponderada dos possíveis valores de uma variável aleatória. Por exemplo, para uma distribuição de notas de exame com probabilidades associadas: 20 (0.1), 40 (0.1), 60 (0.3), 80 (0.4), 100 (0.1), a esperança é calculada como a soma de cada valor multiplicado por sua probabilidade.
Implementação em Python:
def calcular_esperanca(valores, probabilidades):
if len(valores) != len(probabilidades):
return None
soma_ponderada = sum(v * p for v, p in zip(valores, probabilidades))
return soma_ponderada
No exemplo, E(X) = 20*0.1 + 40*0.1 + 60*0.3 + 80*0.4 + 100*0.1 = 66.
- Variância de Variável Aleatória
A variância, σ², mede a dispersão em torno da esperança. É calculada como a soma do quadrado das diferenças entre cada valor e a esperança, ponderada pelas probabilidades.
Implementação em Python:
def calcular_variancia(valores, probabilidades):
media = calcular_esperanca(valores, probabilidades)
if media is None:
return None
variancia = sum(((v - media) ** 2) * p for v, p in zip(valores, probabilidades))
return variancia
- Desvio Padrão de Variável Aleatória
O desvio padrão, σ, é a raiz quadrada da variância, fornecendo uma medida de dispersão na mesma unidade dos valores.
Implementação em Python:
def calcular_desvio_padrao(valores, probabilidades):
variancia = calcular_variancia(valores, probabilidades)
if variancia is None:
return None
desvio = variancia ** 0.5
return desvio
- Covariância Conjunta
A covariância conjunta, σ_xy, indica como duas variáveis aleatórias variam juntas. É calculada como a soma do produto das diferenças de cada valor em relação às suas esperanças, ponderada pelas probabilidades conjuntas.
Implementação em Python:
def calcular_covariancia_conjunta(valores_x, valores_y, probabilidades):
if len(valores_x) != len(valores_y) or len(valores_x) != len(probabilidades):
return None
esperanca_x = calcular_esperanca(valores_x, probabilidades)
esperanca_y = calcular_esperanca(valores_y, probabilidades)
covariancia = sum((x - esperanca_x) * (y - esperanca_y) * p for x, y, p in zip(valores_x, valores_y, probabilidades))
return covariancia
- Retorno Esperado do Portfólio
O retornno esperado de um portfólio é a média ponderada dos retornos esperados dos ativos. Para dois ativos X e Y com pesos w e (1-w), onde w é a proporção investida em X, a fórmula é E(P) = w*E(X) + (1-w)*E(Y).
Implementação em Python:
def calcular_retorno_portfolio(valores_x, valores_y, probabilidades):
total_x = sum(valores_x)
total_y = sum(valores_y)
peso_x = total_x / (total_x + total_y)
peso_y = 1 - peso_x
esperanca_x = calcular_esperanca(valores_x, probabilidades)
esperanca_y = calcular_esperanca(valores_y, probabilidades)
retorno_portfolio = peso_x * esperanca_x + peso_y * esperanca_y
return retorno_portfolio
- Risco do Portfólio
O risco do portfólio é medido pelo desvio padrão do retorno, considerando as variâncias e covariâncias dos ativos. A fórmula é σ(P) = [w²σ_X² + (1-w)²σ_Y² + 2w(1-w)σ_XY]^{0.5}, onde σ_X e σ_Y são os desvios padrão, e σ_XY é a covariância.
Implementação em Python:
def calcular_risco_portfolio(valores_x, valores_y, probabilidades):
total_x = sum(valores_x)
total_y = sum(valores_y)
peso_x = total_x / (total_x + total_y)
peso_y = 1 - peso_x
variancia_x = calcular_variancia(valores_x, probabilidades)
variancia_y = calcular_variancia(valores_y, probabilidades)
covariancia = calcular_covariancia_conjunta(valores_x, valores_y, probabilidades)
risco = (peso_x**2 * variancia_x + peso_y**2 * variancia_y + 2 * peso_x * peso_y * covariancia) ** 0.5
return risco
- Teorema de Bayes
O Teorema de Bayes atualiza probabilidades com base em novas evidências. Para eventos discretos, P(A|B) = [P(B|A) * P(A)] / P(B), onde P(B) é a probabilidade marginal do evento B.
Impllementação simplificada em Python para um cenário com múltiplos eventos:
def calcular_bayes(priori, verossimilhanca, evidencias):
denominador = sum(v * p for v, p in zip(verossimilhanca, priori))
posteriori = [(v * p) / denominador for v, p in zip(verossimilhanca, priori)]
return posteriori
Esta implementação assume que as verossimilhanças e prioris são listas correspondentes, e retorna a distribuição posteriori.