Arquivo de Python - Página 2 de 31

Inteligência Analítica
├── Mineração de Dados
│   ├── Processo KDD
│   │   ├── Pré-Processamento
│   │   ├── Mineração
│   │   └── Pós-Processamento
│   └── Algoritmo de Mineração
│       ├── Associação (algoritmo de mineração)
│       ├── Agrupamento (algoritmo de mineração)
│       ├── Classificação (algoritmo de mineração)
│       ├── Regressão Linear (algoritmo de mineração)
│       ├── RISP-DM (metodologia de processo)
│       └── Comparação entre KDD e CRISP-DM
└── Aprendizado de Máquina
    ├── Supervisionado
    ├── Regressão (dentro de supervisionado)
    └── Classificação (dentro de supervisionado)

O que é inteligência analítica?

Inteligência analítica é o processo de transformar dados brutos em insights acionáveis para decisões. Ela combina estatística, visualização e raciocínio lógico sobre problemas de negócio. Diferentemente da IA generativa, ela foca em entender o passado e o presente. Seu objetivo é responder “o que aconteceu?” e “por que aconteceu?”. Ela é a base para a inteligência competitiva e a mineração de dados. Além disso, ela alimenta modelos preditivos e prescritivos mais avançados. A inteligência analítica é essencial em marketing, finanças e operações. Ela transforma números em narrativas que guiam a estratégia organizacional.

Mineração de dados: o motor da descoberta

Mineração de dados é o processo automatizado de procurar padrões ocultos em grandes conjuntos. Ela usa técnicas de estatística, aprendizado de máquina e bancos de dados. Por exemplo, ela pode descobrir associações entre produtos comprados juntos. Ou pode identificar segmentos de clientes com comportamentos similares. A mineração de dados é exploratória, não confirmatória como a estatística clássica. Ela gera hipóteses que depois são testadas por métodos tradicionais. Além disso, ela lida com dados não estruturados como textos e imagens. Seu uso é comum em detecção de fraudes e análise de sentimentos.

Ciclo de inteligência competitiva: do dado à experiência

O ciclo de inteligência competitiva possui cinco estágios interconectados. Primeiro, os dados são fatos brutos sem contexto ou significado. Em seguida, a informação surge quando dados são organizados e categorizados. O conhecimento é a informação interpretada com regras e experiência humana. A inteligência é o conhecimento aplicado para antecipar cenários futuros. Finalmente, a experiência é a sabedoria acumulada após ciclos repetidos. Cada estágio agrega valor e reduz a incerteza para a tomada de decisão. Esse ciclo é contínuo e se realimenta com novos dados e resultados.

Aplicação e persistência do conhecimento

A aplicação do conhecimento transforma insights em ações concretas no mundo real. Ela pode ser uma recomendação de preço, uma campanha de marketing ou uma rota. A persistência do conhecimento garante que lições aprendidas não sejam perdidas. Ela é armazenada em bases de dados, manuais ou sistemas especialistas. Além disso, a persistência permite reutilização e evolução do conhecimento organizacional. Ela evita que a empresa “reinvente a roda” a cada novo problema. A persistência é facilitada por ferramentas de gestão do conhecimento e wikis.

Inteligência artificial para a inteligência analítica

A IA potencializa a inteligência analítica em várias frentes estratégicas. Ela automatiza a mineração de dados com algoritmos de clustering e classificação. Também acelera o ciclo ao gerar hipóteses automaticamente a partir de padrões. A IA permite analisar dados não estruturados, como textos e imagens. Além disso, ela sugere ações ótimas com base em simulações e otimização. A IA não substitui o analista, mas amplia sua capacidade de processamento. Ela também aprende com os resultados anteriores, melhorando continuamente. Assim, a IA torna a inteligência analítica mais rápida, abrangente e precisa.

A inteligência analítica é uma disciplina madura, mas em constante evolução. Ela se beneficia do crescimento exponencial dos dados disponíveis nas organizações. Contudo, o sucesso depende mais da formulação correta das perguntas. Do que da sofisticação dos algoritmos empregados na análise. O ciclo de inteligência competitiva é um guia para estruturar o raciocínio. Ele evita que a empresa se perca em dados sem propósito claro. A mineração de dados é uma ferramenta poderosa, mas não substitui o julgamento humano. O conhecimento persistente é um ativo intangível que diferencia empresas líderes. A IA para inteligência analítica não é uma bola de cristal. Ela é um assistente que revela o que os dados já estavam escondendo. Portanto, a combinação de dados, ferramentas e pensamento crítico é o segredo. A inteligência analítica não é um destino, mas uma jornada contínua. Ela exige curiosidade, ceticismo saudável e disciplina metodológica. Assim, ela se torna uma competência essencial para qualquer profissional moderno.

Um exemplo prático: uma rede de varejo usa mineração de dados. Ela descobre que clientes que compram fraldas também compram cerveja. Essa informação vira conhecimento sobre hábitos de consumo noturno. A inteligência sugere colocar esses produtos próximos para aumentar vendas. A aplicação gera aumento real de faturamento na loja piloto. O conhecimento é persistido em um manual de layout de lojas. A IA ajuda a encontrar outras associações semelhantes automaticamente. Esse ciclo completo ilustra o poder da inteligência analítica em ação.

O que é o classificador Naive Bayes?

O classificador Naive Bayes é um modelo probabilístico simples baseado no teorema de Bayes. Ele assume que os atributos são condicionalmente independentes dada a classe alvo. Essa suposição “ingênua” (naive) simplifica drasticamente o cálculo das probabilidades. Apesar disso, ele funciona surpreendentemente bem em muitas aplicações reais. A regra de classificação é: classe = argmax P(classe) * ∏ P(atributoᵢ | classe). Ele é treinado estimando as probabilidades condicionais de cada atributo por classe. Para atributos contínuos, assume-se frequentemente uma distribuição normal (gaussiana). Para atributos discretos, usam-se frequências com suavização de Laplace. O Naive Bayes é rápido, escalável e fácil de implementar. Ele é amplamente usado em filtros de spam, análise de sentimentos e diagnóstico.

Características fundamentais do Naive Bayes

O Naive Bayes possui três características principais que o definem. Primeiro, ele é um modelo generativo: modela a distribuição conjunta P(classe, atributos). Segundo, a independência condicional reduz o número de parâmetros drasticamente. Terceiro, ele é robusto a atributos irrelevantes e a dados faltantes. A suposição de independência é forte, mas muitas vezes não prejudica a acurácia. Ele também produz probabilidades bem calibradas quando os dados são balanceados.

Vantagens e limitações típicas

A principal vantagem é a eficiência computacional e a baixa necessidade de dados. Ele é usado em classificação de textos, onde o número de atributos é enorme. Também é aplicado em sistemas de recomendação e previsão de churn. Contudo, a suposição de independência pode falhar em dados com forte correlação.

O Naive Bayes é um caso especial de rede bayesiana com estrutura em estrela. A classe é o nó raiz, e cada atributo é uma folha conectada diretamente a ela. O aprendizado de parâmetros é feito por ML ou MAP (com suavização). Para atributos binários, usa-se a distribuição de Bernoulli. Para atributos categóricos, usa-se a distribuição multinomial. Para atributos contínuos, a Gaussiana é a escolha mais comum. Existem variantes como o Multinomial Naive Bayes para contagens de palavras. E o Bernoulli Naive Bayes para presença/ausência de termos. O Naive Bayes é um bom baseline para problemas de classificação. Ele é surpreendentemente competitivo com métodos mais complexos. Sua interpretabilidade é alta: cada atributo contribui com um fator multiplicativo. A suavização de Laplace evita probabilidades zero para atributos não vistos. A escolha do parâmetro de suavização (α) controla a regularização. Assim, o Naive Bayes é uma ferramenta essencial no kit do cientista de dados.

Um exemplo clássico é a classificação de e-mails como spam ou não-spam. Atributos: presença de palavras como “grátis”, “urgente”, “clique aqui”. O Naive Bayes calcula a probabilidade de spam dada a presença dessas palavras. Ele é rápido e eficaz, mesmo com milhões de e-mails.

Enunciado do exemplo clássico

Implemente o classificador Naive Bayes gaussiano para o dataset Iris (todas as 4 características). Divida em treino (70%) e teste (30%). Calcule médias e variâncias por classe e por atributo. Classifique os dados de teste e calcule a acurácia, precisão e recall por classe. Plote a matriz de confusão e as distribuições condicionais para um atributo (ex.: comprimento da sépala).

import numpy as np  
import matplotlib.pyplot as plt  
from sklearn.datasets import load_iris  
from sklearn.model_selection import train_test_split  
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, classification_report  

# Carregar dados  
iris = load_iris()  
X = iris.data  # 4 atributos  
y = iris.target  
nomes = iris.target_names  

# Dividir  
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)  

# Implementação do Naive Bayes Gaussiano do zero  
class NaiveBayesGaussiano:  
    def fit(self, X, y):  
        self.classes = np.unique(y)  
        self.n_classes = len(self.classes)  
        self.n_atributos = X.shape[1]  
        # Priores  
        self.priors = np.array([np.mean(y == c) for c in self.classes])  
        # Médias e variâncias por classe e atributo  
        self.means = np.zeros((self.n_classes, self.n_atributos))  
        self.vars = np.zeros((self.n_classes, self.n_atributos))  
        for idx, c in enumerate(self.classes):  
            X_c = X[y == c]  
            self.means[idx, :] = np.mean(X_c, axis=0)  
            self.vars[idx, :] = np.var(X_c, axis=0) + 1e-9  # evitar divisão por zero  

    def predict_proba(self, X):  
        n_amostras = X.shape[0]  
        probs = np.zeros((n_amostras, self.n_classes))  
        for idx, c in enumerate(self.classes):  
            # Calcular log-verossimilhança para cada atributo  
            log_lik = -0.5 * np.sum(np.log(2 * np.pi * self.vars[idx, :]))  
            log_lik -= 0.5 * np.sum(((X - self.means[idx, :])**2) / self.vars[idx, :], axis=1)  
            log_lik += np.log(self.priors[idx])  
            probs[:, idx] = log_lik  
        # Converter para probabilidades (softmax)  
        max_log = np.max(probs, axis=1, keepdims=True)  
        exp_probs = np.exp(probs - max_log)  
        return exp_probs / np.sum(exp_probs, axis=1, keepdims=True)  

    def predict(self, X):  
        probs = self.predict_proba(X)  
        return self.classes[np.argmax(probs, axis=1)]  

# Treinar  
nb = NaiveBayesGaussiano()  
nb.fit(X_train, y_train)  

# Prever  
y_pred = nb.predict(X_test)  
y_probs = nb.predict_proba(X_test)  

# Métricas  
acuracia = np.mean(y_pred == y_test)  
print(f"Acurácia: {acuracia:.3f}")  
print("\nRelatório de classificação:")  
print(classification_report(y_test, y_pred, target_names=nomes))  

# Matriz de confusão  
cm = confusion_matrix(y_test, y_pred)  

# Gráficos  
plt.figure(figsize=(12, 5))  

plt.subplot(1, 2, 1)  
ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=nomes).plot(ax=plt.gca(), cmap='Blues')  
plt.title(f'Matriz de Confusão (Acurácia = {acuracia:.3f})')  

plt.subplot(1, 2, 2)  
# Distribuições condicionais para o primeiro atributo (comprimento da sépala)  
atr_idx = 0  
x_vals = np.linspace(X[:, atr_idx].min()-0.5, X[:, atr_idx].max()+0.5, 200)  
for c in nb.classes:  
    mean = nb.means[c, atr_idx]  
    var = nb.vars[c, atr_idx]  
    pdf = (1 / np.sqrt(2 * np.pi * var)) * np.exp(-0.5 * ((x_vals - mean)**2) / var)  
    plt.plot(x_vals, pdf, label=f'{nomes[c]} (μ={mean:.2f}, σ={np.sqrt(var):.2f})')  
    # Histograma dos dados de treino  
    plt.hist(X_train[y_train==c, atr_idx], bins=8, density=True, alpha=0.2)  
plt.xlabel('Comprimento da sépala (cm)')  
plt.ylabel('Densidade')  
plt.title('Distribuições Condicionais - Atributo 0')  
plt.legend()  
plt.grid(True)  

plt.tight_layout()  
plt.show()  

# Exemplo de previsão com probabilidades  
nova_flor = np.array([[5.2, 3.5, 1.5, 0.2]])  
probs = nb.predict_proba(nova_flor)  
pred = nb.predict(nova_flor)  
print(f"\nNova flor com características {nova_flor[0]}:")  
for i, nome in enumerate(nomes):  
    print(f"  P({nome}) = {probs[0][i]:.3f}")  
print(f"Classe predita: {nomes[pred[0]]}")

100

101

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, classification_report

# Carregar dados

iris = load_iris()

X = iris.data # 4 atributos

y = iris.target

nomes = iris.target_names

# Dividir

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Implementação do Naive Bayes Gaussiano do zero

class NaiveBayesGaussiano:

def fit(self, X, y):

self.classes = np.unique(y)

self.n_classes = len(self.classes)

self.n_atributos = X.shape[1]

# Priores

self.priors = np.array([np.mean(y == c) for c in self.classes])

# Médias e variâncias por classe e atributo

self.means = np.zeros((self.n_classes, self.n_atributos))

self.vars = np.zeros((self.n_classes, self.n_atributos))

for idx, c in enumerate(self.classes):

X_c = X[y == c]

self.means[idx, :] = np.mean(X_c, axis=0)

self.vars[idx, :] = np.var(X_c, axis=0) + 1e-9 # evitar divisão por zero

def predict_proba(self, X):

n_amostras = X.shape[0]

probs = np.zeros((n_amostras, self.n_classes))

for idx, c in enumerate(self.classes):

# Calcular log-verossimilhança para cada atributo

log_lik = -0.5 * np.sum(np.log(2 * np.pi * self.vars[idx, :]))

log_lik -= 0.5 * np.sum(((X - self.means[idx, :])**2) / self.vars[idx, :], axis=1)

log_lik += np.log(self.priors[idx])

probs[:, idx] = log_lik

# Converter para probabilidades (softmax)

max_log = np.max(probs, axis=1, keepdims=True)

exp_probs = np.exp(probs - max_log)

return exp_probs / np.sum(exp_probs, axis=1, keepdims=True)

def predict(self, X):

probs = self.predict_proba(X)

return self.classes[np.argmax(probs, axis=1)]

# Treinar

nb = NaiveBayesGaussiano()

nb.fit(X_train, y_train)

# Prever

y_pred = nb.predict(X_test)

y_probs = nb.predict_proba(X_test)

# Métricas

acuracia = np.mean(y_pred == y_test)

print(f"Acurácia: {acuracia:.3f}")

print("\nRelatório de classificação:")

print(classification_report(y_test, y_pred, target_names=nomes))

# Matriz de confusão

cm = confusion_matrix(y_test, y_pred)

# Gráficos

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

plt.subplot(1, 2, 1)

ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=nomes).plot(ax=plt.gca(), cmap='Blues')

plt.title(f'Matriz de Confusão (Acurácia = {acuracia:.3f})')

plt.subplot(1, 2, 2)

# Distribuições condicionais para o primeiro atributo (comprimento da sépala)

atr_idx = 0

x_vals = np.linspace(X[:, atr_idx].min()-0.5, X[:, atr_idx].max()+0.5, 200)

for c in nb.classes:

mean = nb.means[c, atr_idx]

var = nb.vars[c, atr_idx]

pdf = (1 / np.sqrt(2 * np.pi * var)) * np.exp(-0.5 * ((x_vals - mean)**2) / var)

plt.plot(x_vals, pdf, label=f'{nomes[c]} (μ={mean:.2f}, σ={np.sqrt(var):.2f})')

# Histograma dos dados de treino

plt.hist(X_train[y_train==c, atr_idx], bins=8, density=True, alpha=0.2)

plt.xlabel('Comprimento da sépala (cm)')

plt.ylabel('Densidade')

plt.title('Distribuições Condicionais - Atributo 0')

plt.legend()

plt.grid(True)

plt.tight_layout()

plt.show()

# Exemplo de previsão com probabilidades

nova_flor = np.array([[5.2, 3.5, 1.5, 0.2]])

probs = nb.predict_proba(nova_flor)

pred = nb.predict(nova_flor)

print(f"\nNova flor com características {nova_flor[0]}:")

for i, nome in enumerate(nomes):

print(f" P({nome}) = {probs[0][i]:.3f}")

print(f"Classe predita: {nomes[pred[0]]}")

Este código implementa o Naive Bayes gaussiano do zero. As médias e variâncias são estimadas por ML para cada classe e atributo. As distribuições condicionais mostram a separabilidade das classes. A matriz de confusão valida o bom desempenho do classificador. Para iniciantes, este exemplo conecta a teoria à prática de forma completa. O classificador Naive Bayes é, portanto, uma ferramenta poderosa e acessível.

Inteligência Analítica e Inteligência Artificial