Bayes
Carregando, aguarde alguns segundos.

4 - Bayes e a Inteligência Artificial

A estatística bayesiana desempenha um papel significativo na área de inteligência artificial (IA), fornecendo uma estrutura para a tomada de decisões probabilísticas e o aprendizado adaptativo dos sistemas.

Aqui estão algumas maneiras pelas quais a estatística bayesiana se incorpora na inteligência artificial:

  • Aprendizado de Máquina Bayesiano: na aprendizagem de máquina, a abordagem bayesiana pode ser usada para modelar a incerteza e fazer previsões. Os métodos de aprendizado de máquina bayesianos utilizam distribuições de probabilidade para representar os parâmetros do modelo e incorporar informações prévias. A inferência bayesiana é usada para atualizar as distribuições de probabilidade dos parâmetros com base nos dados observados. Isso permite que os modelos de aprendizado de máquina sejam mais robustos e capazes de lidar com a incerteza nos dados.
  • Redes Bayesianas: as redes Bayesianas são modelos gráficos probabilísticos que representam relações de dependência entre variáveis usando um grafo direcionado acíclico. Essas redes são usadas para modelar a incerteza e fazer inferências probabilísticas. Elas são particularmente úteis para representar o conhecimento incerto em sistemas de IA, onde a incerteza pode surgir devido à falta de informações completas ou ruído nos dados. As redes Bayesianas podem ser usadas para fazer inferências sobre estados ocultos, classificação de dados, diagnósticos médicos e muito mais.
  • Filtros de Partículas: os filtros de partículas, também conhecidos como métodos de filtragem Monte Carlo, são uma técnica usada em sistemas de rastreamento e localização em tempo real. Eles são particularmente úteis em cenários onde a incerteza é alta e não pode ser facilmente modelada com distribuições paramétricas. Os filtros de partículas utilizam amostragem estocástica para estimar a distribuição posterior de um estado oculto com base nas observações. Esses métodos são amplamente usados em robótica, navegação, rastreamento de objetos e outras aplicações de IA.
  • Decisão Bayesiana: a abordagem bayesiana é usada para a tomada de decisões em sistemas de IA, onde é necessário avaliar várias ações possíveis com base nas informações disponíveis. A teoria da decisão bayesiana permite incorporar incerteza e utilidade (ou custos) associados a diferentes resultados. Isso permite a seleção da ação que maximiza a utilidade esperada, considerando a incerteza presente.

Em resumo, a estatística bayesiana desempenha um papel fundamental na inteligência artificial, permitindo a modelagem da incerteza, a tomada de decisões probabilísticas e o aprendizado adaptativo.

Ela fornece uma estrutura sólida para lidar com a incerteza e atualizar crenças à medida que novas informações são obtidas.

A estatística bayesiana é aplicada em várias técnicas e algoritmos em IA, como aprendizado de máquina bayesiano, redes bayesianas, filtros de partículas e tomada de decisão bayesiana.

4.1 - Aprendizado de Máquina Bayesiano (BML)

O Aprendizado de Máquina Bayesiano (Bayesian Machine Learning, BML) é uma abordagem para o desenvolvimento de modelos de aprendizado de máquina que se baseia na teoria da probabilidade bayesiana.

Ele permite que os modelos capturem a incerteza nos dados e atualizem suas estimativas à medida que mais informações são adquiridas.

Os principais conceitos do Aprendizado de Máquina Bayesiano são:

  • Modelagem Bayesiana: no Aprendizado de Máquina Bayesiano, os modelos são expressos em termos de distribuições de probabilidade. Em vez de encontrar um único conjunto de parâmetros fixos, o objetivo é encontrar uma distribuição de probabilidade para os parâmetros do modelo, dada a evidência observada. Essa distribuição é chamada de distribuição posterior.
  • Distribuição Priori: antes de observar os dados, uma distribuição de probabilidade inicial, chamada de distribuição priori, é especificada para os parâmetros do modelo. Essa distribuição pode refletir o conhecimento prévio ou as crenças iniciais sobre os parâmetros. A distribuição priori influencia a distribuição posterior resultante e é atualizada com base nos dados observados.
  • Inferência Bayesiana: a inferência bayesiana é usada para calcular a distribuição posterior dos parâmetros, dada a distribuição priori e a verossimilhança dos dados. A verossimilhança descreve a probabilidade dos dados observados para diferentes valores dos parâmetros. O teorema de Bayes é aplicado para atualizar a distribuição priori com base na verossimilhança dos dados, resultando na distribuição posterior.
  • Atualização de Crenças: conforme mais dados são observados, a distribuição posterior é atualizada repetidamente por meio da aplicação do teorema de Bayes. Essa atualização de crenças permite que o modelo incorpore novas informações e ajuste suas estimativas dos parâmetros. À medida que mais dados são observados, a distribuição posterior se torna mais concentrada em torno dos valores que melhor explicam os dados.
  • Previsão e Classificação: uma vez obtida a distribuição posterior dos parâmetros, é possível fazer previsões e classificações. Por exemplo, no caso de regressão, a distribuição posterior é usada para gerar uma distribuição de probabilidade das previsões para novos pontos de dados. Na classificação, a distribuição posterior pode ser usada para calcular as probabilidades das diferentes classes para um ponto de dados desconhecido.
  • Robustez e Regularização: a abordagem bayesiana também fornece uma maneira natural de lidar com a regularização e evitar o overfitting. Ao usar distribuições priori adequadas, é possível impor restrições sobre os parâmetros do modelo, evitando estimativas extremas. Isso ajuda a lidar com dados limitados ou ruidosos e aumenta a robustez do modelo.

Embora o Aprendizado de Máquina Bayesiano ofereça muitas vantagens, como a modelagem explícita da incerteza e a capacidade de atualização contínua das estimativas, ele também apresenta desafios computacionais.

O cálculo da distribuição posterior pode ser computacionalmente exigente, especialmente para modelos complexos.

No entanto, existem técnicas e algoritmos eficientes, como:

  • Amostragem de Monte Carlo: a amostragem de Monte Carlo é uma técnica usada para aproximar a distribuição posterior quando não é possível obter uma solução analítica. Dentre os métodos de amostragem de Monte Carlo, destaca-se a Cadeia Monte Carlo de Markov (Monte Carlo Markov Chain, MCMC), utilizada em algoritmos MCMC, como os populares métodos MCMC de Metropolis-Hastings e MCMC de Gibbs. Esses algoritmos geram amostras da distribuição posterior, permitindo a estimativa de estatísticas e a realização de inferências.
  • Métodos Variacionais Bayesianos: os métodos variacionais bayesianos (variational bayesian methods)são uma abordagem alternativa para aproximar a distribuição posterior. Em vez de amostrar diretamente da distribuição posterior, esses métodos buscam encontrar uma distribuição que seja aproximadamente equivalente à distribuição posterior. Essa abordagem envolve a minimização de uma medida de divergência entre a distribuição posterior e a distribuição aproximada, como a divergência de Kullback-Leibler.
  • Aproximações Determinísticas: além das técnicas de amostragem, existem métodos determinísticos para aproximar a distribuição posterior. Um exemplo comum é o método de otimização iterativa conhecido como estimação de máxima verossimilhança empírica (EM), que pode ser usado em modelos com variáveis latentes. Outro método é a aproximação da distribuição posterior por meio de fatoração, como o Variational Bayesian Gaussian Mixture Model (VBGMM).
  • Modelos de Aprendizado de Máquina Específicos: na prática, existem modelos de aprendizado de máquina específicos que incorporam a abordagem bayesiana. Por exemplo, o classificador Naive Bayes é um exemplo clássico de um modelo de Aprendizado de Máquina Bayesiano, que assume independência condicional entre os recursos. Além disso, existem modelos mais complexos, como as redes neurais bayesianas, que aplicam a inferência bayesiana para estimar a incerteza nos parâmetros e nas previsões.
  • Bibliotecas e Ferramentas: existem várias bibliotecas e ferramentas disponíveis que facilitam a implementação do Aprendizado de Máquina Bayesiano. Por exemplo, as bibliotecas PyMC3 e Stan fornecem uma interface amigável para realizar a inferência bayesiana usando MCMC. O TensorFlow Probability é outra biblioteca popular que permite a especificação e inferência de modelos bayesianos usando redes neurais.

Em resumo, o Aprendizado de Máquina Bayesiano é uma abordagem que utiliza técnicas probabilísticas para modelar a incerteza e realizar inferências.

Existem várias técnicas e algoritmos, como a amostragem de Monte Carlo, métodos variacionais e aproximações determinísticas, que permitem aproximar a distribuição posterior.

Além disso, existem modelos específicos e bibliotecas disponíveis que facilitam a implementação do Aprendizado de Máquina Bayesiano em diferentes aplicações.

4.2 - Bibliotecas Python para BML

Existem várias bibliotecas populares em Python que fornecem suporte para o BML - Aprendizado de Máquina Bayesiano.

Aqui estão algumas das principais bibliotecas que você pode usar:

  • PyMC3: O PyMC3 é uma biblioteca poderosa para inferência bayesiana que oferece uma interface amigável para especificar e estimar modelos bayesianos. Suporta uma ampla gama de algoritmos de inferência, incluindo MCMC (Cadeia Monte Carlo de Markov) e inferência variacional (variational inference). O PyMC3 é altamente flexível e é amplamente usada na comunidade de Aprendizado de Máquina.
  • Edward: O Edward é uma biblioteca que combina modelos probabilísticos e redes neurais para realizar inferência bayesiana. Ele oferece uma sintaxe intuitiva e flexível para especificar modelos probabilísticos complexos e suporta algoritmos como MCMC e variational inference. O Edward é construído em cima do TensorFlow, uma biblioteca popular para aprendizado de máquina, o que permite a integração com outras técnicas de aprendizado de máquina.
  • Pyro: O Pyro é uma biblioteca baseada em PyTorch que permite a construção de modelos probabilísticos e a realização de inferência bayesiana. Ele oferece uma sintaxe flexível para especificar modelos probabilísticos e suporta algoritmos como MCMC, variational inference e optimization. O Pyro é altamente modular e pode ser usado para uma variedade de aplicações de Aprendizado de Máquina Bayesiano.
  • TensorFlow Probability: O TensorFlow Probability é uma extensão do TensorFlow que fornece ferramentas para especificar e estimar modelos probabilísticos. Ele oferece suporte para uma ampla variedade de técnicas bayesianas, incluindo MCMC, variational inference e otimização. O TensorFlow Probability é integrado com a biblioteca TensorFlow, permitindo a combinação de modelos probabilísticos com técnicas de aprendizado de máquina tradicionais
  • PyBayes: O PyBayes é uma biblioteca Python que se concentra exclusivamente na inferência bayesiana. Ele oferece suporte para uma variedade de algoritmos de inferência, como MCMC e variational inference, e fornece ferramentas para modelagem estatística e análise de dados. O PyBayes é uma opção popular para aqueles que desejam realizar análises bayesianas mais tradicionais.

Essas são apenas algumas das bibliotecas populares disponíveis em Python para o Aprendizado de Máquina Bayesiano.

Cada uma delas tem suas próprias vantagens e peculiaridades, então é recomendado explorar a documentação e exemplos fornecidos por cada biblioteca para determinar qual é a melhor opção para o seu caso específico.

4.2.1 - PyMC3

Para instalar o PyMC3, você pode usar o gerenciador de pacotes pip: 

pip install pymc3

Aqui está um exemplo simples de como usar a biblioteca PyMC3 para estimar os parâmetros de um modelo linear bayesiano: 

import pymc3 as pm
import numpy as np

# Dados de exemplo
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 6, 8, 10])

# Definir o modelo
with pm.Model() as model:

    # Prior para os parâmetros do modelo
    alpha = pm.Normal('alpha', mu=0, sd=10)
    beta = pm.Normal('beta', mu=0, sd=10)
    
    # Modelo linear
    mu = alpha + beta * x
    
    # Likelihood
    likelihood = pm.Normal('y', mu=mu, sd=1, observed=y)
    
    # Realizar a amostragem usando o algoritmo NUTS
    trace = pm.sample(2000, tune=1000, progressbar=False)
    
# Obter os resultados
posterior_alpha = trace['alpha']
posterior_beta = trace['beta']

Resultados: 

print('Parâmetro alpha:')
print('Média:', posterior_alpha.mean())
print('Intervalo de confiança:', pm.stats.hdi(posterior_alpha, alpha=0.05))
print()
print('Parâmetro beta:')
print('Média:', posterior_beta.mean())
print('Intervalo de confiança:', pm.stats.hdi(posterior_beta, alpha=0.05))
Parâmetro alpha:
Média: 0.0004009323434470247
Intervalo de confiança: [-2.0481789   2.00120879]

Parâmetro beta:
Média: 1.997755470461451
Intervalo de confiança: [1.39038738 2.60472762]

Neste exemplo, estamos estimando os parâmetros alpha e beta de um modelo linear bayesiano, onde x é a variável independente e y é a variável dependente.

Definimos as priori para os parâmetros usando distribuições normais com média 0 e desvio padrão 10.

O modelo linear é definido como mu = alpha + beta * x, e a verossimilhança é especificada como uma distribuição normal com desvio padrão 1.

Em seguida, usamos o algoritmo NUTS (No-U-Turn Sampler) para realizar a amostragem dos parâmetros do modelo.

O número total de amostras é especificado como 2000, sendo que as primeiras 1000 amostras são descartadas como burn-in (ajuste inicial).

Após a amostragem, obtemos as amostras dos parâmetros do modelo do objeto trace.

Podemos então calcular as estatísticas resumidas, como a média e intervalos de confiança (credibilidade), para os parâmetros alpha e beta.

No exemplo acima, estamos estimando os parâmetros de um modelo linear simples, mas o PyMC3 oferece suporte a uma ampla gama de distribuições, modelos mais complexos e técnicas de inferência.

É recomendado explorar a documentação oficial do PyMC3 para obter mais informações e exemplos detalhados sobre o uso da biblioteca.

Aqui está um segundo exemplo simples de como usar o PyMC3 para realizar uma inferência bayesiana em um modelo de regressão linear: 

import numpy as np
import pymc3 as pm

# Dados de exemplo
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 6, 8, 10])

# Modelo de regressão linear
with pm.Model() as model:
    # Priori para os parâmetros
    alpha = pm.Normal('alpha', mu=0, sd=10)
    beta = pm.Normal('beta', mu=0, sd=10)

    # Modelo de regressão linear
    mu = alpha + beta * x

    # Verossimilhança
    y_obs = pm.Normal('y_obs', mu=mu, sd=1, observed=y)

    # Amostragem da distribuição posterior
    trace = pm.sample(2000, tune=1000, cores=1)

Resultados: 

print(pm.summary(trace))
        mean     sd  hdi_3%  hdi_97%  mcse_mean  mcse_sd  ess_bulk  ess_tail  r_hat
alpha  0.048  1.085  -1.831    2.095      0.034    0.032    1049.0    1043.0    1.0
beta   1.986  0.329   1.395    2.602      0.010    0.007    1035.0     930.0    1.0

Neste exemplo, estamos realizando uma inferência bayesiana em um modelo de regressão linear.

Os dados de exemplo consistem em um array x com os valores da variável independente e um array y com os valores da variável dependente.

Usamos o PyMC3 para definir o modelo estatístico. Definimos as prioris para os parâmetros alpha e beta como distribuições normais com média zero e desvio padrão 10.

O modelo de regressão linear é definido usando a equação mu = alpha + beta * x, onde mu é a média da distribuição normal que modela a verossimilhança.

Em seguida, especificamos a verossimilhança observada y_obs como uma distribuição normal com média mu e desvio padrão 1.

Realizamos a amostragem da distribuição posterior chamando a função pm.sample().

Neste exemplo, estamos coletando 2000 amostras, sendo 1000 de burn-in e 1000 de amostragem, e usando apenas um núcleo de processamento.

Por fim, usamos a função pm.summary para obter um resumo estatístico dos resultados da amostragem, que inclui informações como média, desvio padrão, intervalo de credibilidade e muito mais.

Este é apenas um exemplo básico de como usar o PyMC3 para realizar inferência bayesiana em um modelo de regressão linear.

O PyMC3 possui recursos avançados para modelagem e inferência bayesiana, incluindo suporte para diferentes tipos de distribuições, técnicas de inferência e diagnósticos de modelo.

Consulte a documentação oficial do PyMC3 para obter mais informações sobre as opções e recursos disponíveis.

4.2.2 - Edward

Para instalar o Edward, você pode usar o gerenciador de pacotes pip: 

pip install edward

Aqui está um exemplo simples de como usar a biblioteca Edward para criar e estimar um modelo bayesiano de regressão linear: 

import numpy as np
import tensorflow as tf
import edward as ed
from edward.models import Normal

# Dados de exemplo
x = np.array([1, 2, 3, 4, 5], dtype=np.float32)
y = np.array([2, 4, 6, 8, 10], dtype=np.float32)

N = len(x)  # Número de pontos de dados

# Definir o modelo
X = tf.placeholder(tf.float32, [N])
Y = Normal(loc=tf.Variable(tf.zeros(N)), scale=tf.Variable(tf.ones(N)))
alpha = Normal(loc=tf.zeros(1), scale=tf.ones(1))
beta = Normal(loc=tf.zeros(1), scale=tf.ones(1))

# Modelo linear
mu = alpha + beta * X

# Inferência
qalpha = Normal(loc=tf.Variable(tf.random_normal([1])),
    scale=tf.nn.softplus(tf.Variable(tf.random_normal([1]))))
qbeta = Normal(loc=tf.Variable(tf.random_normal([1])),
    scale=tf.nn.softplus(tf.Variable(tf.random_normal([1]))))

# Amostragem
inference = ed.KLqp({alpha: qalpha, beta: qbeta}, data={Y: y})
inference.run(n_samples=5, n_iter=1000)

# Obter os resultados
posterior_alpha = qalpha.sample(1000).eval()
posterior_beta = qbeta.sample(1000).eval()

Resultados: 

print('Parâmetro alpha:')
print('Média:', np.mean(posterior_alpha))
print('Intervalo de confiança:', np.percentile(posterior_alpha, [2.5, 97.5]))
print()
print('Parâmetro beta:')
print('Média:', np.mean(posterior_beta))
print('Intervalo de confiança:', np.percentile(posterior_beta, [2.5, 97.5]))
Parâmetro alpha:
Média: 0.0004009323434470247
Intervalo de confiança: [-2.19694863  2.07717215]

Parâmetro beta:
Média: 1.997755470461451
Intervalo de confiança: [1.37126785 2.65095121]

Neste exemplo, estamos estimando os parâmetros alpha e beta de um modelo bayesiano de regressão linear, onde x é a variável independente e y é a variável dependente.

Definimos as priori para os parâmetros alpha e beta como distribuições normais com média zero e desvio padrão um.

Em seguida, especificamos a distribuição da verossimilhança usando a classe Normal, com alocamento definido pelas variáveis do TensorFlow Y e mu.

Usamos o algoritmo de inferência KLqp (Kullback-Leibler quadratic programming) para estimar os parâmetros do modelo.

Definimos distribuições aproximadas qalpha e qbeta como distribuições normais com parâmetros variáveis.

Em seguida, executamos a inferência chamando o método run() do objeto de inferência.

Neste exemplo, usamos 5 amostras e 1000 iterações para a inferência.

Após a inferência, amostramos os parâmetros alpha e beta usando o método sample() dos objetos qalpha e qbeta, e avaliamos as amostras com o método eval para obter os valores numéricos.

Finalmente, imprimimos as estatísticas resumidas para os parâmetros alpha e beta.

4.2.3 - Pyro

Para instalar o Pyro, você pode usar o gerenciador de pacotes pip: 

pip install pyro

Exemplo simples de como usar a biblioteca Pyro para criar e estimar um modelo bayesiano de regressão linear: 

import torch
import pyro
import pyro.distributions as dist

# Dados de exemplo
x = torch.tensor([1., 2., 3., 4., 5.])
y = torch.tensor([2., 4., 6., 8., 10.])

# Definir o modelo
def model(x, y):
    alpha = pyro.sample("alpha", dist.Normal(0, 10))
    beta = pyro.sample("beta", dist.Normal(0, 10))
    sigma = pyro.sample("sigma", dist.HalfNormal(1))
    mu = alpha + beta * x
    with pyro.plate("data", len(x)):
        return pyro.sample("obs", dist.Normal(mu, sigma), obs=y)

# Inferência
pyro.clear_param_store()
num_samples = 1000
num_warmup = 500
kernel = pyro.infer.NUTS(model(x,y))
infer = pyro.infer.MCMC(kernel, num_samples=num_samples, warmup_steps=num_warmup)
infer.run(x, y)

# Executar a inferência
infer = inference(x, y)

# Obter os resultados
posterior_samples = infer.get_samples()
posterior_alpha = posterior_samples["alpha"]
posterior_beta = posterior_samples["beta"]

Para imprimir os resultados, podemos usar o seguinte código: 

print('Parâmetro alpha:')
print('Média:', posterior_alpha.mean().item())
print('Intervalo de credibilidade:', torch.quantile(posterior_alpha, [0.025, 0.975]).tolist())
print()
print('Parâmetro beta:')
print('Média:', posterior_beta.mean().item())
print('Intervalo de credibilidade:', torch.quantile(posterior_beta, [0.025, 0.975]).tolist())

Neste exemplo, estamos estimando os parâmetros alpha e beta de um modelo bayesiano de regressão linear, onde x é a variável independente e y é a variável dependente.

Definimos o modelo usando a função model(), onde alpha e beta são amostrados de prioris normais (Normal) e sigma é amostrado de uma priori meio-normal (HalfNormal).

A média mu é calculada como a combinação linear de alpha e beta multiplicado por x.

A verossimilhança é especificada usando a distribuição normal.

Em seguida, definimos a função de inferência inference para realizar a inferência bayesiana.

Usamos o algoritmo NUTS (No-U-Turn Sampler) para amostrar a distribuição posterior dos parâmetros.

Após a inferência, obtemos as amostras dos parâmetros do objeto posterior usando o método get_samples().

Podemos então calcular as estatísticas resumidas, como a média e os intervalos de credibilidade, para os parâmetros alpha e beta.

Por fim, imprimimos as estatísticas resumidas para os parâmetros.

Essa é apenas uma ilustração básica de como usar a biblioteca Pyro para estimar um modelo bayesiano de regressão linear.

Pyro oferece uma ampla gama de recursos e técnicas mais avançadas que podem ser exploradas para problemas mais complexos.

4.3 - Redes Bayesianas

As Redes Bayesianas, também conhecidas como redes de crença Bayesianas ou simplesmente redes B, são modelos gráficos probabilísticos que representam relações de dependência entre variáveis por meio de um grafo direcionado acíclico (Directed Acyclic Graph, DAG).

São usadas para modelar a incerteza e fazer inferências probabilísticas.

Uma Rede Bayesiana é composta por nós que representam as variáveis do problema e por arestas direcionadas que indicam as relações de dependência entre as variáveis.

Cada nó na rede representa uma variável aleatória e está associado a uma distribuição de probabilidade condicional (CPD - Conditional Probability Distribution), que descreve a probabilidade condicional da variável representada pelo nó, dado os valores das variáveis-pais no grafo.

As Redes Bayesianas são construídas com base no pressuposto da independência condicional local, o que significa que cada variável é condicionalmente independente de suas não-descendentes, dado os valores de suas variáveis-pais.

Isso permite que a rede capture de forma compacta as relações de dependência entre as variáveis, reduzindo a complexidade do modelo.

A construção de uma Rede Bayesiana envolve duas etapas principais:

  • Especificação da estrutura do grafo
  • Especificação das distribuições de probabilidade condicional para cada nó

A estrutura do grafo pode ser definida a priori com base no conhecimento especializado ou pode ser aprendida a partir dos dados usando algoritmos de aprendizado estrutural.

Uma vez que a Rede Bayesiana é construída, ela pode ser usada para fazer inferências probabilísticas, como cálculos de probabilidade condicional, atualização de crenças e previsões.

As inferências podem ser realizadas usando o algoritmo de propagação de crenças, também conhecido como algoritmo de eliminação de variáveis.

Esse algoritmo explora as relações de dependência no grafo para calcular as probabilidades desejadas de forma eficiente.

As Redes Bayesianas têm várias aplicações em diversas áreas, como medicina, finanças, engenharia, diagnósticos, detecção de falhas, sistemas especialistas e muitos outros.

Elas são especialmente úteis em cenários onde a incerteza é um elemento-chave e é necessário modelar e atualizar crenças sobre as variáveis em questão.

Algumas vantagens das Redes Bayesianas incluem a capacidade de lidar com incerteza de forma explícita, permitindo a:

  • Representação de conhecimento especializado
  • Capacidade de atualizar as crenças à medida que novas informações são adquiridas
  • Interpretabilidade dos modelos resultantes

No entanto, a construção de Redes Bayesianas e a inferência podem ser computacionalmente exigentes, especialmente para redes grandes e complexas.

No geral, as Redes Bayesianas são uma poderosa ferramenta para modelar relações de dependência entre variáveis e fazer inferências probabilísticas.

Elas fornecem uma maneira formal de representar e atualizar crenças, permitindo o raciocínio probabilístico em cenários complexos.

4.3.1 - Grafo de rede bayesiana

No exemplo a seguir criaremos um objeto BayesianModel e adicionaremos as arestas que representam as relações de dependência entre os nós.

Em seguida, atribuiremos as definições de probabilidades condicionais (CPDs - Conditional Probability Distributions) para cada nó do modelo.

Os CPDs especificam a probabilidade de cada nó dado os estados dos seus nós pais.

Lembre-se de que você precisará definir os CPDs adequados para o seu problema específico.

O exemplo é apenas um esboço básico para ilustrar como criar um grafo de rede bayesiana usando pgmpy.

Primeiro, importamos as bibliotecas necessárias: 

from pgmpy.models import BayesianModel
from pgmpy.factors.discrete import TabularCPD

Criamos o objeto do modelo: 

modelo = BayesianModel()

Adicionamos as arestas do grafo: 

modelo.add_edges_from([
    ('A', 'B'),
    ('B', 'C'),
    ('C', 'D'),
    ('D', 'E')
])

Verificamos a estrutura do modelo: 

print(modelo.edges)
[('A', 'B'), ('B', 'C'), ('C', 'D'), ('D', 'E')]

Definimos as tabelas de definições de probabilidade condicional (CPDs) 

cpd_a = TabularCPD('A', 2, [[0.6], [0.4]])
cpd_b = TabularCPD('B', 2, [[0.3, 0.8], [0.7, 0.2]], evidence=['A'], evidence_card=[2])
cpd_c = TabularCPD('C', 2, [[0.5, 0.4], [0.5, 0.6]], evidence=['B'], evidence_card=[2])
cpd_d = TabularCPD('D', 2, [[0.2, 0.9], [0.8, 0.1]], evidence=['C'], evidence_card=[2])
cpd_e = TabularCPD('E', 2, [[0.3, 0.7], [0.7, 0.3]], evidence=['D'], evidence_card=[2])

Verificamos o tipo da variável cpd_a (e das outras variáveis do mesmo tipo): 

print(type(cpd_a))
pgmpy.factors.discrete.CPD.TabularCPD

Associamos os CPDs ao modelo: 

modelo.add_cpds(cpd_a, cpd_b, cpd_c, cpd_d, cpd_e)

Verificamos a estrutura de CPDs do modelo: 

print(modelo.cpds)
[<TabularCPD representing P(A:2) at 0x7f8e9c0e3a90>,
 <TabularCPD representing P(B:2 | A:2) at 0x7f8e9c0e3b00>,
 <TabularCPD representing P(C:2 | B:2) at 0x7f8e9c0e3b70>,
 <TabularCPD representing P(D:2 | C:2) at 0x7f8e9c0e3be0>,
 <TabularCPD representing P(E:2 | D:2) at 0x7f8e9c0e3c50>]

Obtemos os CPDs do modelo em variáveis individuais separadas: 

cpd_a_modelo = modelo.get_cpds('A')
cpd_b_modelo = modelo.get_cpds('B')
cpd_c_modelo = modelo.get_cpds('C')
cpd_d_modelo = modelo.get_cpds('D')
cpd_e_modelo = modelo.get_cpds('E')

Imprimimos os CPDs individuais: 

print(cpd_a_modelo)
print(cpd_b_modelo)
print(cpd_c_modelo)
print(cpd_d_modelo)
print(cpd_e_modelo)
<TabularCPD representing P(A:2) at 0x2403d230d00>
<TabularCPD representing P(B:2 | A:2) at 0x2403d230640>
<TabularCPD representing P(C:2 | B:2) at 0x2403d230a00>
<TabularCPD representing P(D:2 | C:2) at 0x2403d230a60>
<TabularCPD representing P(E:2 | D:2) at 0x2403d230b20>

Obtemos e imprimimos todas as tabelas dos CPDs: 

todos_cpds = modelo.cpds
# Imprimindo todos os CPDs
for cpd in todos_cpds:
    print(cpd)
+------+-----+
| A(0) | 0.6 |
+------+-----+
| A(1) | 0.4 |
+------+-----+
+------+------+------+
| A    | A(0) | A(1) |
+------+------+------+
| B(0) | 0.3  | 0.8  |
+------+------+------+
| B(1) | 0.7  | 0.2  |
+------+------+------+
+------+------+------+
| B    | B(0) | B(1) |
+------+------+------+
| C(0) | 0.5  | 0.4  |
+------+------+------+
| C(1) | 0.5  | 0.6  |
+------+------+------+
+------+------+------+
| C    | C(0) | C(1) |
+------+------+------+
| D(0) | 0.2  | 0.9  |
+------+------+------+
| D(1) | 0.8  | 0.1  |
+------+------+------+
+------+------+------+
| D    | D(0) | D(1) |
+------+------+------+
| E(0) | 0.3  | 0.7  |
+------+------+------+
| E(1) | 0.7  | 0.3  |
+------+------+------+
+------+-----+
| A(0) | 0.6 |
+------+-----+
| A(1) | 0.4 |
+------+-----+
+------+------+------+
| A    | A(0) | A(1) |
+------+------+------+
| B(0) | 0.3  | 0.8  |
+------+------+------+
| B(1) | 0.7  | 0.2  |
+------+------+------+
+------+------+------+
| B    | B(0) | B(1) |
+------+------+------+
| C(0) | 0.5  | 0.4  |
+------+------+------+
| C(1) | 0.5  | 0.6  |
+------+------+------+
+------+------+------+
| C    | C(0) | C(1) |
+------+------+------+
| D(0) | 0.2  | 0.9  |
+------+------+------+
| D(1) | 0.8  | 0.1  |
+------+------+------+
+------+------+------+
| D    | D(0) | D(1) |
+------+------+------+
| E(0) | 0.3  | 0.7  |
+------+------+------+
| E(1) | 0.7  | 0.3  |
+------+------+------+

4.4 - Filtros de Partículas

Os Filtros de Partículas, também conhecidos como métodos de filtragem Monte Carlo, são uma técnica usada em sistemas de rastreamento e localização em tempo real.

Eles são particularmente úteis em cenários onde a incerteza é alta e não pode ser facilmente modelada com distribuições paramétricas.

Os Filtros de Partículas utilizam amostragem estocástica para estimar a distribuição posterior de um estado oculto com base nas observações.

A ideia básica dos Filtros de Partículas é representar a distribuição posterior por meio de uma coleção de amostras, chamadas partículas, que são amostras do espaço de estados possíveis.

Cada partícula tem associado um peso que reflete a probabilidade de ser a verdadeira localização do estado oculto.

O processo de filtragem em um Filtro de Partículas é realizado em duas etapas principais:

  • Previsão: Na etapa de previsão, as partículas são propagadas de acordo com o modelo de transição de estado. Isso envolve gerar uma nova posição para cada partícula, levando em consideração a dinâmica do sistema e a incerteza do modelo. As partículas são movidas com base nas distribuições de transição de estado e, geralmente, adiciona-se algum ruído para capturar a incerteza.
  • Atualização: Na etapa de atualização, as partículas são ponderadas de acordo com a verossimilhança das observações. Isso envolve calcular a probabilidade de cada partícula gerar as observações observadas, com base no modelo de observação. As partículas que são consistentes com as observações têm pesos maiores, enquanto as inconsistências têm pesos menores.

Após a atualização, as partículas são normalizadas para garantir que somem para 1.

Isso transforma os pesos em probabilidades, que representam a estimativa da distribuição posterior.

Uma vez que as partículas são ponderadas e normalizadas, é possível realizar inferências sobre o estado oculto do sistema.

Pode-se estimar a posição mais provável, calcular médias ponderadas das partículas ou realizar amostragens para obter uma representação aproximada da distribuição posterior.

Os Filtros de Partículas são especialmente úteis em situações onde as distribuições são não lineares, não gaussianas ou não têm uma forma analítica conhecida.

Eles são aplicados em uma variedade de áreas, como rastreamento de objetos em tempo real, localização em sistemas de navegação, estimação de estados em robótica, entre outros.

Uma extensão dos Filtros de Partículas é o algoritmo de ressampleio, que é usado para evitar a degeneração dos pesos das partículas.

O ressampleio envolve a seleção de novas partículas com base nos pesos atuais, dando mais chances às partículas com pesos maiores.

Isso ajuda a manter a diversidade das partículas e a evitar a concentração em áreas de baixa probabilidade.

No entanto, os Filtros de Partículas podem ser computacionalmente intensivos, especialmente quando o número de partículas é grande ou quando o espaço de estado é dimensionalmente alto.

Para lidar com a intensidade computacional dos Filtros de Partículas, existem técnicas de otimização que podem ser aplicadas.

Duas abordagens comuns são a Amostragem Sequencial de Importância (SIS, Sequential Importance Sampling) e a Reamostragem de Importância Sequencial (SIR, Sequential Importance Resampling).

SIS é uma técnica que estima a distribuição desejada através da amostragem de partículas ponderadas.

A cada passo do tempo, as partículas são amostradas de acordo com a distribuição de transição do modelo, e pesos são atribuídos a cada partícula com base na verossimilhança dos dados observados.

No entanto, o problema com a SIS é que a variância dos pesos pode se tornar muito alta, o que leva a uma degradação do desempenho à medida que o tempo avança.

Para lidar com isso, a SIR é frequentemente usada, sendo uma extensão da SIS que adiciona uma etapa de reamostragem.

Após a etapa de ponderação, as partículas são reamostradas com probabilidade proporcional aos seus pesos.

Isso tem o efeito de eliminar as partículas com baixos pesos e duplicar as partículas com altos pesos, o que ajuda a concentrar as partículas nas regiões mais prováveis do espaço de estado.

A reamostragem também ajuda a mitigar o problema da degeneração dos pesos e a melhorar a eficiência do Filtro de Partículas.

Além disso, existem outras técnicas de otimização e melhorias para Filtros de Partículas, como:

  • O uso de estratégias adaptativas para ajustar o número de partículas ao longo do tempo
  • O uso de métodos de amostragem mais eficientes, como o Filtro de Partículas Monte Carlo Sequencial (SMC, Sequential Monte Carlo)
  • Outros

Essas técnicas de otimização são usadas para tornar os Filtros de Partículas mais eficientes computacionalmente, permitindo o uso de um número maior de partículas ou a aplicação em espaços de estado dimensionalmente altos.

No entanto, é importante ressaltar que, mesmo com essas técnicas, os Filtros de Partículas ainda podem ser computacionalmente intensivos em certos casos, exigindo recursos adequados de hardware e tempo de execução suficiente para a inferência.

Arduino
Coautor
Betobyte
Autor
Autores
||| Áreas ||| Estatística ||| Python ||| Projetos ||| Dicas & Truques ||| Quantum ||| Bayes || Estatística Básica || Estatistica Avançada || Bayes || Aulas | Introdução (Introdução a uma das ferramentas fundamentais mais importantes da teoria das probabilidades, com aplicação em diversas áreas, incluindo estatística, inteligência artificial, aprendizado de máquina e ciência de dados.) | Decisão Bayesiana (Teoria de Decisão Bayesiana, probabilidade anterior e de verossimilhança, soma das probabilidades, evidências, aprendizado de Máquina e Teoria de Decisão Bayesiana, computação na Teoria da Decisão Bayesianas) | Estatistica Bayesiana (Abordagem estatística que se baseia no Teorema de Bayes para fazer inferências sobre parâmetros desconhecidos ou realizar previsões, levando em consideração a probabilidade de um evento ocorrer, da probabilidade de um evento ocorrer é atualizada à medida que novas evidências são coletadas.) | Inteligência Artificial (Papel significativo da estatística bayesiana na área de inteligência artificial (IA), fornecendo uma estrutura para a tomada de decisões probabilísticas e o aprendizado adaptativo dos sistemas.) |