Arquivo de Python - Página 5 de 31

Risco Bayesiano

16/07/202618/06/2026 Por antonino

O que é o risco bayesiano?

O risco bayesiano é o valor esperado da função de perda sob a distribuição a posteriori. Ele mede o custo médio de uma decisão, dado os dados observados e o conhecimento prévio. Matematicamente, R(a|x) = ∫ L(θ, a) * P(θ|x) dθ, onde a é a ação escolhida. A decisão ótima é aquela que minimiza esse risco esperado. O risco bayesiano é uma medida subjetiva, pois depende da perda e do prior. Ele é fundamental para comparar diferentes regras de decisão. Uma regra é chamada de “admissível” se não existe outra com risco menor para todo θ. O risco bayesiano mínimo é o valor da função de perda no ponto ótimo. Ele também é usado para avaliar a qualidade de estimadores pontuais.

Características fundamentais do risco bayesiano

O risco bayesiano possui três características principais que o definem. Primeiro, ele é um número escalar para cada ação possível. Segundo, ele integra a incerteza sobre o parâmetro θ. Terceiro, ele permite comparação direta entre ações concorrentes. A função de perda pode ser quadrática, absoluta, 0-1 ou assimétrica. Cada perda leva a um estimador diferente (média, mediana, moda, etc.). O risco bayesiano é frequentemente usado em problemas de estimação e classificação.

Vantagens e aplicações típicas

A principal vantagem é a incorporação de custos reais na tomada de decisão. Ele é usado em controle de qualidade, diagnóstico e planejamento financeiro. Também é aplicado em aprendizado por reforço e otimização de portfólio. Contudo, a escolha da função de perda pode ser arbitrária e influenciar o resultado.

O risco bayesiano é a base da teoria da decisão estatística. Para perda quadrática, o risco bayesiano é a variância a posteriori. Para perda 0-1, o risco é a probabilidade de erro de classificação. O estimador de Bayes (que minimiza o risco) é ótimo para a perda escolhida. O risco mínimo é chamado de “risco de Bayes” e é um limite inferior. Nenhum outro estimador pode ter risco médio menor (sob o mesmo prior). Isso é análogo ao erro de Bayes em classificação. O risco bayesiano pode ser calculado analiticamente para modelos conjugados. Para modelos complexos, usa-se MCMC para aproximar a integral. O risco também pode ser decomposto em viés² + variância (para perda quadrática). Essa decomposição ajuda a entender o compromisso entre viés e variância. Em problemas de decisão sequencial, o risco é acumulado ao longo do tempo. A programação dinâmica busca minimizar o risco total esperado. Assim, o risco bayesiano é um conceito unificador em estatística e aprendizado.

Um exemplo clássico é estimar a média μ de uma normal com prior normal. A perda quadrática leva à média a posteriori como estimador. O risco bayesiano desse estimador é a variância a posteriori. Quanto mais informativo o prior, menor o risco.

Enunciado do exemplo clássico

Implemente o cálculo do risco bayesiano para estimação da média de uma normal com prior normal. Dados: 10 observações de N(μ, σ²=4). Prior: μ ~ N(0, 1). Perda quadrática. Calcule a média a posteriori e o risco bayesiano (variância a posteriori) para uma amostra específica. Plote o risco como função do tamanho da amostra e como função do parâmetro de precisão do prior.

import numpy as np  
import matplotlib.pyplot as plt  
from scipy.stats import norm  

# Configuração do problema  
sigma2 = 4.0  # variância dos dados (conhecida)  
prior_mean = 0.0  
prior_var = 1.0  # variância do prior  

# Gerar uma amostra sintética  
np.random.seed(10)  
n = 10  
mu_real = 2.0  
dados = np.random.normal(mu_real, np.sqrt(sigma2), n)  

# Fórmulas para posteriori (normal-normal conjugada)  
def posterior_norm(dados, sigma2, prior_mean, prior_var):  
    n = len(dados)  
    # Precisões  
    prec_dados = n / sigma2  
    prec_prior = 1.0 / prior_var  
    # Média posterior  
    peso_dados = prec_dados / (prec_dados + prec_prior)  
    peso_prior = prec_prior / (prec_dados + prec_prior)  
    mean_post = peso_dados * np.mean(dados) + peso_prior * prior_mean  
    var_post = 1.0 / (prec_dados + prec_prior)  
    return mean_post, var_post  

# Calcular para os dados atuais  
mu_post, var_post = posterior_norm(dados, sigma2, prior_mean, prior_var)  
print(f"Tamanho da amostra: {n}")  
print(f"Média amostral: {np.mean(dados):.3f}")  
print(f"Média a posteriori: {mu_post:.3f}")  
print(f"Variância a posteriori (risco Bayesiano quadrático): {var_post:.4f}")  

# Calcular risco Bayesiano teórico (para perda quadrática)  
# O risco é a variância a posteriori, que diminui com n e com a precisão do prior  

# Gráfico 1: Risco vs tamanho da amostra (usando a mesma média amostral)  
n_vals = np.arange(1, 51)  
riscos_n = []  
for n_aux in n_vals:  
    # Usar os primeiros n_aux dados (ou simular nova amostra? Usamos os mesmos dados)  
    # Para consistência, usamos a média amostral dos primeiros n_aux  
    if n_aux <= len(dados):  
        dados_aux = dados[:n_aux]  
    else:  
        # Estender com dados adicionais simulados da mesma distribuição  
        extras = np.random.normal(mu_real, np.sqrt(sigma2), n_aux - len(dados))  
        dados_aux = np.concatenate([dados, extras])  
    _, var_post_aux = posterior_norm(dados_aux, sigma2, prior_mean, prior_var)  
    riscos_n.append(var_post_aux)  

plt.figure(figsize=(12, 5))  

plt.subplot(1, 2, 1)  
plt.plot(n_vals, riscos_n, 'b-', linewidth=2)  
plt.xlabel('Tamanho da amostra (n)')  
plt.ylabel('Risco Bayesiano (variância posterior)')  
plt.title('Risco Bayesiano vs. Tamanho da Amostra')  
plt.grid(True)  

# Gráfico 2: Risco vs variância do prior (precisão)  
prior_vars = np.linspace(0.1, 10, 100)  
riscos_prior = []  
for pv in prior_vars:  
    _, var_post_aux = posterior_norm(dados, sigma2, prior_mean, pv)  
    riscos_prior.append(var_post_aux)  

plt.subplot(1, 2, 2)  
plt.plot(prior_vars, riscos_prior, 'r-', linewidth=2)  
plt.xlabel('Variância do prior (τ²)')  
plt.ylabel('Risco Bayesiano (variância posterior)')  
plt.title('Risco Bayesiano vs. Incerteza do Prior')  
plt.grid(True)  
plt.tight_layout()  
plt.show()  

# Comparação com o estimador de máxima verossimilhança (MLE)  
# Risco da MLE = σ²/n (variância amostral)  
risco_mle = sigma2 / n  
print(f"\nRisco do estimador MLE (variância): {risco_mle:.4f}")  
print(f"Risco do estimador Bayesiano (variância posterior): {var_post:.4f}")  
print("O Bayesiano tem risco menor (prior informativo).")  

# Demonstrar perda 0-1 para classificação (ilustrativo)  
# Suponha que queremos decidir se μ > 1.5. Perda 0-1.  
# O risco é a probabilidade de errar.  
prob_pos = 1 - norm.cdf(1.5, mu_post, np.sqrt(var_post))  
prob_neg = 1 - prob_pos  
risco_01 = min(prob_pos, prob_neg)  # decisão MAP  
print(f"\nPara perda 0-1 (decidir μ > 1.5):")  
print(f"  P(μ > 1.5 | dados) = {prob_pos:.3f}")  
print(f"  Risco (prob. de erro) = {risco_01:.3f}")

import numpy as np

import matplotlib.pyplot as plt

from scipy.stats import norm

# Configuração do problema

sigma2 = 4.0 # variância dos dados (conhecida)

prior_mean = 0.0

prior_var = 1.0 # variância do prior

# Gerar uma amostra sintética

np.random.seed(10)

n = 10

mu_real = 2.0

dados = np.random.normal(mu_real, np.sqrt(sigma2), n)

# Fórmulas para posteriori (normal-normal conjugada)

def posterior_norm(dados, sigma2, prior_mean, prior_var):

n = len(dados)

# Precisões

prec_dados = n / sigma2

prec_prior = 1.0 / prior_var

# Média posterior

peso_dados = prec_dados / (prec_dados + prec_prior)

peso_prior = prec_prior / (prec_dados + prec_prior)

mean_post = peso_dados * np.mean(dados) + peso_prior * prior_mean

var_post = 1.0 / (prec_dados + prec_prior)

return mean_post, var_post

# Calcular para os dados atuais

mu_post, var_post = posterior_norm(dados, sigma2, prior_mean, prior_var)

print(f"Tamanho da amostra: {n}")

print(f"Média amostral: {np.mean(dados):.3f}")

print(f"Média a posteriori: {mu_post:.3f}")

print(f"Variância a posteriori (risco Bayesiano quadrático): {var_post:.4f}")

# Calcular risco Bayesiano teórico (para perda quadrática)

# O risco é a variância a posteriori, que diminui com n e com a precisão do prior

# Gráfico 1: Risco vs tamanho da amostra (usando a mesma média amostral)

n_vals = np.arange(1, 51)

riscos_n = []

for n_aux in n_vals:

# Usar os primeiros n_aux dados (ou simular nova amostra? Usamos os mesmos dados)

# Para consistência, usamos a média amostral dos primeiros n_aux

if n_aux <= len(dados):

dados_aux = dados[:n_aux]

else:

# Estender com dados adicionais simulados da mesma distribuição

extras = np.random.normal(mu_real, np.sqrt(sigma2), n_aux - len(dados))

dados_aux = np.concatenate([dados, extras])

_, var_post_aux = posterior_norm(dados_aux, sigma2, prior_mean, prior_var)

riscos_n.append(var_post_aux)

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)

plt.plot(n_vals, riscos_n, 'b-', linewidth=2)

plt.xlabel('Tamanho da amostra (n)')

plt.ylabel('Risco Bayesiano (variância posterior)')

plt.title('Risco Bayesiano vs. Tamanho da Amostra')

plt.grid(True)

# Gráfico 2: Risco vs variância do prior (precisão)

prior_vars = np.linspace(0.1, 10, 100)

riscos_prior = []

for pv in prior_vars:

_, var_post_aux = posterior_norm(dados, sigma2, prior_mean, pv)

riscos_prior.append(var_post_aux)

plt.subplot(1, 2, 2)

plt.plot(prior_vars, riscos_prior, 'r-', linewidth=2)

plt.xlabel('Variância do prior (τ²)')

plt.ylabel('Risco Bayesiano (variância posterior)')

plt.title('Risco Bayesiano vs. Incerteza do Prior')

plt.grid(True)

plt.tight_layout()

plt.show()

# Comparação com o estimador de máxima verossimilhança (MLE)

# Risco da MLE = σ²/n (variância amostral)

risco_mle = sigma2 / n

print(f"\nRisco do estimador MLE (variância): {risco_mle:.4f}")

print(f"Risco do estimador Bayesiano (variância posterior): {var_post:.4f}")

print("O Bayesiano tem risco menor (prior informativo).")

# Demonstrar perda 0-1 para classificação (ilustrativo)

# Suponha que queremos decidir se μ > 1.5. Perda 0-1.

# O risco é a probabilidade de errar.

prob_pos = 1 - norm.cdf(1.5, mu_post, np.sqrt(var_post))

prob_neg = 1 - prob_pos

risco_01 = min(prob_pos, prob_neg) # decisão MAP

print(f"\nPara perda 0-1 (decidir μ > 1.5):")

print(f" P(μ > 1.5 | dados) = {prob_pos:.3f}")

print(f" Risco (prob. de erro) = {risco_01:.3f}")

Este código calcula o risco bayesiano para estimação da média com perda quadrática. O risco é a variância a posteriori, que diminui com mais dados. Prior mais incerto (variância alta) aumenta o risco, pois confia menos no prior. O estimador bayesiano tem risco menor que o MLE quando o prior é informativo. Para perda 0-1, o risco é a probabilidade de erro na decisão. Para iniciantes, este exemplo mostra como o risco quantifica a qualidade da decisão. O risco bayesiano é, portanto, uma métrica fundamental em estatística decisória.

Teoria da Decisao Bayesiana

16/07/202618/06/2026 Por antonino

O que é a teoria da decisão bayesiana?

A teoria da decisão bayesiana é um arcabouço matemático para tomar decisões sob incerteza. Ela combina probabilidades (crenças) com custos ou utilidades associados a cada ação. A decisão ótima minimiza o risco esperado, ou maximiza a utilidade esperada. O risco é calculado integrando a perda sobre a distribuição a posteriori dos parâmetros. Diferentemente da abordagem frequentista, ela incorpora conhecimento prévio (prior). A decisão é adaptativa: novos dados atualizam a posteriori e a escolha ótima. Ela é usada em diagnósticos, controle, economia e aprendizado de máquina. A teoria formaliza o princípio de que “a melhor ação depende do que sabemos”. Portanto, ela une estatística, otimização e teoria dos jogos.

Componentes fundamentais da decisão bayesiana

A teoria possui três elementos principais que a estruturam. Primeiro, o espaço de estados (parâmetros ou classes) com distribuição a priori. Segundo, o espaço de ações disponíveis para o decisor. Terceiro, uma função de perda L(θ, a) que mede o custo de tomar ação a quando o estado é θ. A decisão bayesiana escolhe a ação que minimiza o risco posterior: R(a|x) = E[L(θ,a) | x]. Para perda quadrática, a decisão é a média da posteriori. Para perda 0-1 (classificação), a decisão é a moda (MAP).

Vantagens e aplicações típicas

A principal vantagem é a flexibilidade para incorporar custos assimétricos. Ela é usada em diagnósticos médicos (falso negativo tem custo alto). Também em finanças (perda vs. ganho) e em sistemas de recomendação. Contudo, a especificação da função de perda é subjetiva e desafiadora.

A teoria da decisão bayesiana é a base do aprendizado supervisionado probabilístico. No contexto de classificação, a perda 0-1 leva ao classificador MAP. Se a perda for assimétrica, define-se uma matriz de custos. Por exemplo, em detecção de fraudes, o custo de não detectar é muito maior. A decisão ótima pode escolher a classe com menor custo esperado, não a mais provável. A regra de decisão de Bayes minimiza o erro esperado em média. Ela também pode ser usada para seleção de modelos (fator de Bayes). Em problemas de estimação, a perda quadrática produz a média a posteriori. A perda absoluta produz a mediana da posteriori. A teoria também trata de decisões sequenciais com múltiplos estágios. Nesse caso, usa-se programação dinâmica ou processos de decisão de Markov (POMDP). A função de utilidade pode ser não-linear, representando aversão ao risco. A teoria é frequentemente contrastada com a abordagem minimax (pior caso). Assim, a decisão bayesiana é uma ferramenta poderosa e flexível para escolhas racionais.

Um exemplo clássico é o problema do diagnóstico de uma doença rara. A priori: P(doente) = 0.01. Teste com sensibilidade 95% e especificidade 90%. Custos: falso negativo (não tratar doente) = 100, falso positivo (tratar saudável) = 1. A decisão bayesiana calcula o custo esperado de tratar ou não tratar, dado o teste positivo.

Enunciado do exemplo clássico

Implemente a decisão bayesiana para um problema de diagnóstico com custos assimétricos. Prior: P(doente) = 0.02. Teste binário com sensibilidade P(pos|doente)=0.90 e especificidade P(neg|saudável)=0.85. Matriz de custos: C(tratar | saudável) = 10, C(não tratar | doente) = 100, C(tratar | doente) = 0, C(não tratar | saudável) = 0. Calcule o risco esperado de cada ação (tratar vs não tratar) para um resultado positivo e negativo. Plote os riscos como função da probabilidade a priori de doença.

import numpy as np  
import matplotlib.pyplot as plt  

# Dados do problema  
prior_doente = 0.02  
sensibilidade = 0.90  
especificidade = 0.85  
# Matriz de custos: [ação][estado]  
# Ação 0: não tratar, Ação 1: tratar  
# Estado 0: saudável, Estado 1: doente  
C = np.array([[0, 100],   # [não tratar][saudável, doente]  
              [10, 0]])   # [tratar][saudável, doente]  

# Probabilidades do teste  
P_pos_dado_doente = sensibilidade  
P_neg_dado_doente = 1 - sensibilidade  
P_pos_dado_saudavel = 1 - especificidade  
P_neg_dado_saudavel = especificidade  

# Função para calcular probabilidades posteriores e riscos  
def decisao(prior_doente, resultado):  
    # resultado: 'pos' ou 'neg'  
    if resultado == 'pos':  
        P_pos = prior_doente * P_pos_dado_doente + (1-prior_doente) * P_pos_dado_saudavel  
        P_doente_dado_pos = prior_doente * P_pos_dado_doente / P_pos  
        P_saudavel_dado_pos = 1 - P_doente_dado_pos  
        # Risco de não tratar  
        R_nao_tratar = C[0,0] * P_saudavel_dado_pos + C[0,1] * P_doente_dado_pos  
        # Risco de tratar  
        R_tratar = C[1,0] * P_saudavel_dado_pos + C[1,1] * P_doente_dado_pos  
        return R_nao_tratar, R_tratar, P_doente_dado_pos, P_saudavel_dado_pos  
    else:  # negativo  
        P_neg = prior_doente * P_neg_dado_doente + (1-prior_doente) * P_neg_dado_saudavel  
        P_doente_dado_neg = prior_doente * P_neg_dado_doente / P_neg  
        P_saudavel_dado_neg = 1 - P_doente_dado_neg  
        R_nao_tratar = C[0,0] * P_saudavel_dado_neg + C[0,1] * P_doente_dado_neg  
        R_tratar = C[1,0] * P_saudavel_dado_neg + C[1,1] * P_doente_dado_neg  
        return R_nao_tratar, R_tratar, P_doente_dado_neg, P_saudavel_dado_neg  

# Calcular para teste positivo  
R_nao_pos, R_trata_pos, P_doente_pos, P_saud_pos = decisao(prior_doente, 'pos')  
print("Resultado POSITIVO:")  
print(f"  P(doente | pos) = {P_doente_pos:.4f}")  
print(f"  Risco não tratar = {R_nao_pos:.2f}")  
print(f"  Risco tratar     = {R_trata_pos:.2f}")  
print(f"  Decisão: {'TRATAR' if R_trata_pos < R_nao_pos else 'NÃO TRATAR'}")  

# Calcular para teste negativo  
R_nao_neg, R_trata_neg, P_doente_neg, P_saud_neg = decisao(prior_doente, 'neg')  
print("\nResultado NEGATIVO:")  
print(f"  P(doente | neg) = {P_doente_neg:.4f}")  
print(f"  Risco não tratar = {R_nao_neg:.2f}")  
print(f"  Risco tratar     = {R_trata_neg:.2f}")  
print(f"  Decisão: {'TRATAR' if R_trata_neg < R_nao_neg else 'NÃO TRATAR'}")  

# Gráfico: risco como função do prior para resultado positivo  
priors = np.linspace(0.001, 0.1, 100)  
risco_nao = []  
risco_trat = []  
for p in priors:  
    R_nao, R_trat, _, _ = decisao(p, 'pos')  
    risco_nao.append(R_nao)  
    risco_trat.append(R_trat)  

plt.figure(figsize=(12, 5))  

plt.subplot(1, 2, 1)  
plt.plot(priors, risco_nao, 'b-', linewidth=2, label='Risco: Não tratar')  
plt.plot(priors, risco_trat, 'r-', linewidth=2, label='Risco: Tratar')  
# Marcar ponto do prior atual  
idx = np.argmin(np.abs(priors - prior_doente))  
plt.axvline(prior_doente, color='gray', linestyle='--', label=f'Prior = {prior_doente}')  
plt.scatter(prior_doente, risco_nao[idx], color='blue', s=80)  
plt.scatter(prior_doente, risco_trat[idx], color='red', s=80)  
plt.xlabel('Probabilidade a priori de doença')  
plt.ylabel('Risco esperado')  
plt.title('Risco da Decisão (teste positivo)')  
plt.legend()  
plt.grid(True)  

plt.subplot(1, 2, 2)  
# Mostrar a matriz de custos e resumo  
texto = (f"Matriz de Custos:\n"  
         f"            Saudável   Doente\n"  
         f"Não tratar    0        100\n"  
         f"Tratar       10          0\n\n"  
         f"Sensibilidade = {sensibilidade:.2f}\n"  
         f"Especificidade = {especificidade:.2f}\n\n"  
         f"Prior = {prior_doente:.3f}\n"  
         f"P(doente | pos) = {P_doente_pos:.3f}\n"  
         f"Decisão (pos): {'TRATAR' if R_trata_pos < R_nao_pos else 'NÃO TRATAR'}\n"  
         f"Decisão (neg): {'TRATAR' if R_trata_neg < R_nao_neg else 'NÃO TRATAR'}")  
plt.text(0.1, 0.5, texto, fontsize=12, family='monospace',  
         bbox=dict(facecolor='lightyellow', alpha=0.9))  
plt.axis('off')  
plt.title('Resumo da Decisão Bayesiana')  

plt.tight_layout()  
plt.show()

import numpy as np

import matplotlib.pyplot as plt

# Dados do problema

prior_doente = 0.02

sensibilidade = 0.90

especificidade = 0.85

# Matriz de custos: [ação][estado]

# Ação 0: não tratar, Ação 1: tratar

# Estado 0: saudável, Estado 1: doente

C = np.array([[0, 100], # [não tratar][saudável, doente]

[10, 0]]) # [tratar][saudável, doente]

# Probabilidades do teste

P_pos_dado_doente = sensibilidade

P_neg_dado_doente = 1 - sensibilidade

P_pos_dado_saudavel = 1 - especificidade

P_neg_dado_saudavel = especificidade

# Função para calcular probabilidades posteriores e riscos

def decisao(prior_doente, resultado):

# resultado: 'pos' ou 'neg'

if resultado == 'pos':

P_pos = prior_doente * P_pos_dado_doente + (1-prior_doente) * P_pos_dado_saudavel

P_doente_dado_pos = prior_doente * P_pos_dado_doente / P_pos

P_saudavel_dado_pos = 1 - P_doente_dado_pos

# Risco de não tratar

R_nao_tratar = C[0,0] * P_saudavel_dado_pos + C[0,1] * P_doente_dado_pos

# Risco de tratar

R_tratar = C[1,0] * P_saudavel_dado_pos + C[1,1] * P_doente_dado_pos

return R_nao_tratar, R_tratar, P_doente_dado_pos, P_saudavel_dado_pos

else: # negativo

P_neg = prior_doente * P_neg_dado_doente + (1-prior_doente) * P_neg_dado_saudavel

P_doente_dado_neg = prior_doente * P_neg_dado_doente / P_neg

P_saudavel_dado_neg = 1 - P_doente_dado_neg

R_nao_tratar = C[0,0] * P_saudavel_dado_neg + C[0,1] * P_doente_dado_neg

R_tratar = C[1,0] * P_saudavel_dado_neg + C[1,1] * P_doente_dado_neg

return R_nao_tratar, R_tratar, P_doente_dado_neg, P_saudavel_dado_neg

# Calcular para teste positivo

R_nao_pos, R_trata_pos, P_doente_pos, P_saud_pos = decisao(prior_doente, 'pos')

print("Resultado POSITIVO:")

print(f" P(doente | pos) = {P_doente_pos:.4f}")

print(f" Risco não tratar = {R_nao_pos:.2f}")

print(f" Risco tratar = {R_trata_pos:.2f}")

print(f" Decisão: {'TRATAR' if R_trata_pos < R_nao_pos else 'NÃO TRATAR'}")

# Calcular para teste negativo

R_nao_neg, R_trata_neg, P_doente_neg, P_saud_neg = decisao(prior_doente, 'neg')

print("\nResultado NEGATIVO:")

print(f" P(doente | neg) = {P_doente_neg:.4f}")

print(f" Risco não tratar = {R_nao_neg:.2f}")

print(f" Risco tratar = {R_trata_neg:.2f}")

print(f" Decisão: {'TRATAR' if R_trata_neg < R_nao_neg else 'NÃO TRATAR'}")

# Gráfico: risco como função do prior para resultado positivo

priors = np.linspace(0.001, 0.1, 100)

risco_nao = []

risco_trat = []

for p in priors:

R_nao, R_trat, _, _ = decisao(p, 'pos')

risco_nao.append(R_nao)

risco_trat.append(R_trat)

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)

plt.plot(priors, risco_nao, 'b-', linewidth=2, label='Risco: Não tratar')

plt.plot(priors, risco_trat, 'r-', linewidth=2, label='Risco: Tratar')

# Marcar ponto do prior atual

idx = np.argmin(np.abs(priors - prior_doente))

plt.axvline(prior_doente, color='gray', linestyle='--', label=f'Prior = {prior_doente}')

plt.scatter(prior_doente, risco_nao[idx], color='blue', s=80)

plt.scatter(prior_doente, risco_trat[idx], color='red', s=80)

plt.xlabel('Probabilidade a priori de doença')

plt.ylabel('Risco esperado')

plt.title('Risco da Decisão (teste positivo)')

plt.legend()

plt.grid(True)

plt.subplot(1, 2, 2)

# Mostrar a matriz de custos e resumo

texto = (f"Matriz de Custos:\n"

f" Saudável Doente\n"

f"Não tratar 0 100\n"

f"Tratar 10 0\n\n"

f"Sensibilidade = {sensibilidade:.2f}\n"

f"Especificidade = {especificidade:.2f}\n\n"

f"Prior = {prior_doente:.3f}\n"

f"P(doente | pos) = {P_doente_pos:.3f}\n"

f"Decisão (pos): {'TRATAR' if R_trata_pos < R_nao_pos else 'NÃO TRATAR'}\n"

f"Decisão (neg): {'TRATAR' if R_trata_neg < R_nao_neg else 'NÃO TRATAR'}")

plt.text(0.1, 0.5, texto, fontsize=12, family='monospace',

bbox=dict(facecolor='lightyellow', alpha=0.9))

plt.axis('off')

plt.title('Resumo da Decisão Bayesiana')

plt.tight_layout()

plt.show()

Este código implementa a decisão bayesiana com custos assimétricos. O risco de tratar ou não tratar é calculado para cada resultado do teste. O gráfico mostra como os riscos variam com a probabilidade a priori. A decisão ótima muda conforme a prior e os custos relativos. Para iniciantes, este exemplo conecta probabilidade à tomada de decisão. A teoria da decisão bayesiana é, portanto, essencial para escolhas racionais sob incerteza.