Arquivo de Python - Página 24 de 92

Imagine que você é um treinador de futebol avaliando novos jogadores. Dois atletas estão à mesma distância física de você, mas um está dentro do campo e outro está na arquibancada. A distância euclidiana diria que estão igualmente próximos, mas seu instinto sabe que o jogador no campo está muito mais “perto” do contexto do futebol. A distância de Mahalanobis é como esse instinto treinado – ela considera a distribuição e correlação dos dados para medir distâncias de forma mais inteligente e contextual.

Como isso funciona na prática?

A distância de Mahalanobis vai beyond da simples geometria ao considerar a estrutura de covariância dos dados. Enquanto a distância euclidiana mede distâncias “em linha reta”, a Mahalanobis mede distâncias em termos de desvios padrão da distribuição. Ela automaticamente leva em conta que algumas direções nos dados são mais variáveis que outras, e que características podem estar correlacionadas. Na implementação do Scikit-Learn, essa sofisticação matemática é encapsulada em interfaces simples, permitindo que você use métricas avançadas com a mesma facilidade das básicas.

Mãos na massa: implementando a distância de Mahalanobis no Scikit-Learn

"""
Implementação da distância de Mahalanobis e comparação com outras métricas
Demonstra detecção de outliers e classificação com distâncias inteligentes
"""

import numpy as np
from sklearn.neighbors import NearestNeighbors
from sklearn.covariance import EmpiricalCovariance
from scipy.spatial.distance import mahalanobis
import matplotlib.pyplot as plt

# Gerando dados de jogadores de futebol correlacionados
# [altura_cm, peso_kg, velocidade_kmh] - características naturalmente correlacionadas
np.random.seed(42)
n_jogadores = 100

# Criando dados com correlação entre altura e peso
alturas = np.random.normal(180, 8, n_jogadores)
pesos = alturas * 0.4 + np.random.normal(70, 5, n_jogadores)  # Peso correlacionado com altura
velocidades = np.random.normal(32, 3, n_jogadores)

dados_jogadores = np.column_stack([alturas, pesos, velocidades])

# Calculando a matriz de covariância para a distância de Mahalanobis
covariancia = EmpiricalCovariance().fit(dados_jogadores)
matriz_covariancia = covariancia.covariance_
inversa_covariancia = np.linalg.inv(matriz_covariancia)

print("Matriz de covariância dos dados:")
print(matriz_covariancia)

# Calculando distância de Mahalanobis manualmente
def distancia_mahalanobis_manual(x, y, inv_cov):
    """Implementação manual da fórmula: √((x-y)ᵀ × Σ⁻¹ × (x-y))"""
    diferenca = x - y
    return np.sqrt(diferenca.T @ inv_cov @ diferenca)

# Testando com um jogador médio e um outlier
jogador_medio = np.mean(dados_jogadores, axis=0)
jogador_outlier = np.array([160, 90, 25])  # Baixo, pesado, lento - padrão incomum

# Comparando diferentes distâncias
dist_euclidiana = np.linalg.norm(jogador_medio - jogador_outlier)
dist_mahalanobis_manual = distancia_mahalanobis_manual(jogador_medio, jogador_outlier, inversa_covariancia)
dist_mahalanobis_scipy = mahalanobis(jogador_medio, jogador_outlier, inversa_covariancia)

print(f"\nComparação de distâncias para o jogador outlier:")
print(f"Distância Euclidiana: {dist_euclidiana:.2f}")
print(f"Distância Mahalanobis (manual): {dist_mahalanobis_manual:.2f}")
print(f"Distância Mahalanobis (SciPy): {dist_mahalanobis_scipy:.2f}")

# Usando NearestNeighbors com métrica personalizada (implementação prática)
def mahalanobis_metric(x, y, VI=inversa_covariancia):
    """Métrica personalizada para usar com NearestNeighbors"""
    diferenca = x - y
    return np.sqrt(diferenca @ VI @ diferenca)

vizinhos = NearestNeighbors(n_neighbors=5, metric=mahalanobis_metric)
vizinhos.fit(dados_jogadores)

# Encontrando vizinhos mais próximos usando Mahalanobis
distancias, indices = vizinhos.kneighbors(jogador_medio.reshape(1, -1))
print(f"\nVizinhos mais próximos do jogador médio (Mahalanobis): {indices[0]}")

"""

Implementação da distância de Mahalanobis e comparação com outras métricas

Demonstra detecção de outliers e classificação com distâncias inteligentes

"""

import numpy as np

from sklearn.neighbors import NearestNeighbors

from sklearn.covariance import EmpiricalCovariance

from scipy.spatial.distance import mahalanobis

import matplotlib.pyplot as plt

# Gerando dados de jogadores de futebol correlacionados

# [altura_cm, peso_kg, velocidade_kmh] - características naturalmente correlacionadas

np.random.seed(42)

n_jogadores = 100

# Criando dados com correlação entre altura e peso

alturas = np.random.normal(180, 8, n_jogadores)

pesos = alturas * 0.4 + np.random.normal(70, 5, n_jogadores) # Peso correlacionado com altura

velocidades = np.random.normal(32, 3, n_jogadores)

dados_jogadores = np.column_stack([alturas, pesos, velocidades])

# Calculando a matriz de covariância para a distância de Mahalanobis

covariancia = EmpiricalCovariance().fit(dados_jogadores)

matriz_covariancia = covariancia.covariance_

inversa_covariancia = np.linalg.inv(matriz_covariancia)

print("Matriz de covariância dos dados:")

print(matriz_covariancia)

# Calculando distância de Mahalanobis manualmente

def distancia_mahalanobis_manual(x, y, inv_cov):

"""Implementação manual da fórmula: √((x-y)ᵀ × Σ⁻¹ × (x-y))"""

diferenca = x - y

return np.sqrt(diferenca.T @ inv_cov @ diferenca)

# Testando com um jogador médio e um outlier

jogador_medio = np.mean(dados_jogadores, axis=0)

jogador_outlier = np.array([160, 90, 25]) # Baixo, pesado, lento - padrão incomum

# Comparando diferentes distâncias

dist_euclidiana = np.linalg.norm(jogador_medio - jogador_outlier)

dist_mahalanobis_manual = distancia_mahalanobis_manual(jogador_medio, jogador_outlier, inversa_covariancia)

dist_mahalanobis_scipy = mahalanobis(jogador_medio, jogador_outlier, inversa_covariancia)

print(f"\nComparação de distâncias para o jogador outlier:")

print(f"Distância Euclidiana: {dist_euclidiana:.2f}")

print(f"Distância Mahalanobis (manual): {dist_mahalanobis_manual:.2f}")

print(f"Distância Mahalanobis (SciPy): {dist_mahalanobis_scipy:.2f}")

# Usando NearestNeighbors com métrica personalizada (implementação prática)

def mahalanobis_metric(x, y, VI=inversa_covariancia):

"""Métrica personalizada para usar com NearestNeighbors"""

diferenca = x - y

return np.sqrt(diferenca @ VI @ diferenca)

vizinhos = NearestNeighbors(n_neighbors=5, metric=mahalanobis_metric)

vizinhos.fit(dados_jogadores)

# Encontrando vizinhos mais próximos usando Mahalanobis

distancias, indices = vizinhos.kneighbors(jogador_medio.reshape(1, -1))

print(f"\nVizinhos mais próximos do jogador médio (Mahalanobis): {indices[0]}")

Os detalhes que fazem diferença

A grande vantagem da distância de Mahalanobis é sua capacidade de lidar com dados correlacionados e de diferentes escalas naturalmente. Enquanto com distâncias euclidianas você precisaria normalizar os dados manualmente, a Mahalanobis faz isso automaticamente através da matriz de covariância. Contudo, essa sofisticação vem com um custo computacional maior e a necessidade de estimar reliably a matriz de covariância. Analogamente importante é entender que a Mahalanobis assume uma distribuição aproximadamente normal multivariada; com distribuições muito assimétricas ou multimodais, seu desempenho pode degradar.

Melhor uso: Dados correlacionados com distribuição aproximadamente normal
Vantagem principal: Considera automaticamente escalas e correlações
Limitação: Sensível a estimativas ruins da matriz de covariância
Implementação: Use EmpiricalCovariance para estimativa robusta

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Quando devo usar Mahalanobis em vez de Euclidiana?” Excelente questão! Use Mahalanobis quando suas características estiverem em escalas diferentes e/ou correlacionadas, especialmente para detecção de outliers. Uma confusão comum é pensar que Mahalanobis sempre performa melhor – na verdade, com dados não correlacionados e bem normalizados, Euclidiana pode ser suficiente e mais rápida. Outra dúvida frequente: “Como a implementação no Scikit-Learn lida com matrizes de covariância singulares?” Ela usa técnicas de regularização para evitar problemas numéricos, mas é sempre bom verificar a qualidade da sua estimativa de covariância.

Para onde ir agora?

Experimente usar a distância de Mahalanobis em seus próprios dados esportivos ou de outras áreas. Comece comparando resultados com Euclidiana e observe as diferenças. Implemente uma métrica personalizada no NearestNeighbors para problemas específicos. O momento “aha!” acontece quando você vê a Mahalanobis identificando padrões e outliers que passariam despercebidos com outras métricas.

Assuntos relacionados

Para dominar a distância de Mahalanobis, estude estes conceitos matemáticos:

Estatística multivariada: covariância, correlação e distribuições normais
Álgebra linear: matrizes, inversas e formas quadráticas
Geometria: elipsoides e transformações de escala
Teoria da probabilidade: distribuições conjuntas e condicionais
Otimização: minimização de distâncias em espaços transformados

Referências que valem a pena

Como isso funciona na prática?

A formulação matemática é a linguagem universal que descreve como os algoritmos realmente funcionam. Enquanto as implementações em código mostram o “como”, a matemática explica o “porquê”. Por exemplo, o KNN parece simples conceitualmente, mas sua formulação matemática envolve otimização de distâncias em espaços multidimensionais. Analogamente, algoritmos como SVM usam conceitos avançados de geometria para encontrar o hiperplano ótimo que separa classes. Entender estas formulações permite que você escolha algoritmos de forma inteligente e ajuste parâmetros com propósito, não por tentativa e erro.

Mãos na massa: implementando a matemática do KNN

"""
Implementação da formulação matemática do KNN do zero
Demonstra os cálculos de distância e classificação por trás do algoritmo
"""

import numpy as np
from collections import Counter

class KNNMatematica:
    def __init__(self, k=3):
        self.k = k
    
    def distancia_euclidiana(self, ponto1, ponto2):
        """Calcula a distância euclidiana entre dois pontos"""
        # Fórmula: √Σ(x_i - y_i)²
        return np.sqrt(np.sum((ponto1 - ponto2) ** 2))
    
    def fit(self, X, y):
        """Armazena os dados de treinamento - algoritmo 'preguiçoso'"""
        self.X_treino = X
        self.y_treino = y
    
    def predict(self, X):
        """Faz previsões baseando-se nos k vizinhos mais próximos"""
        previsoes = []
        for ponto in X:
            # Calcula distâncias para todos os pontos de treinamento
            distancias = [self.distancia_euclidiana(ponto, x_treino) 
                         for x_treino in self.X_treino]
            
            # Encontra os índices dos k vizinhos mais próximos
            indices_vizinhos = np.argsort(distancias)[:self.k]
            
            # Obtém os rótulos dos vizinhos
            rotulos_vizinhos = [self.y_treino[i] for i in indices_vizinhos]
            
            # Encontra o rótulo mais comum (moda)
            rotulo_mais_comum = Counter(rotulos_vizinhos).most_common(1)[0][0]
            previsoes.append(rotulo_mais_comum)
        
        return np.array(previsoes)

# Dados de exemplo: características de pães [peso_farinha, tempo_fermentacao, temperatura]
X_treino = np.array([
    [500, 120, 25],  # Pão francês
    [300, 90, 28],   # Pão de forma
    [400, 180, 22],  # Pão integral
    [350, 100, 26],  # Pão de forma
    [450, 150, 23]   # Pão integral
])
y_treino = np.array(['francês', 'forma', 'integral', 'forma', 'integral'])

# Criando e treinando nosso KNN matemático
knn = KNNMatematica(k=3)
knn.fit(X_treino, y_treino)

# Novo pão para classificar
novo_pao = np.array([[380, 110, 26]])
previsao = knn.predict(novo_pao)

print(f"O novo pão foi classificado como: {previsao[0]}")
print("Baseado nos cálculos matemáticos de distância e votação dos vizinhos!")

"""

Implementação da formulação matemática do KNN do zero

Demonstra os cálculos de distância e classificação por trás do algoritmo

"""

import numpy as np

from collections import Counter

class KNNMatematica:

def __init__(self, k=3):

self.k = k

def distancia_euclidiana(self, ponto1, ponto2):

"""Calcula a distância euclidiana entre dois pontos"""

# Fórmula: √Σ(x_i - y_i)²

return np.sqrt(np.sum((ponto1 - ponto2) ** 2))

def fit(self, X, y):

"""Armazena os dados de treinamento - algoritmo 'preguiçoso'"""

self.X_treino = X

self.y_treino = y

def predict(self, X):

"""Faz previsões baseando-se nos k vizinhos mais próximos"""

previsoes = []

for ponto in X:

# Calcula distâncias para todos os pontos de treinamento

distancias = [self.distancia_euclidiana(ponto, x_treino)

for x_treino in self.X_treino]

# Encontra os índices dos k vizinhos mais próximos

indices_vizinhos = np.argsort(distancias)[:self.k]

# Obtém os rótulos dos vizinhos

rotulos_vizinhos = [self.y_treino[i] for i in indices_vizinhos]

# Encontra o rótulo mais comum (moda)

rotulo_mais_comum = Counter(rotulos_vizinhos).most_common(1)[0][0]

previsoes.append(rotulo_mais_comum)

return np.array(previsoes)

# Dados de exemplo: características de pães [peso_farinha, tempo_fermentacao, temperatura]

X_treino = np.array([

[500, 120, 25], # Pão francês

[300, 90, 28], # Pão de forma

[400, 180, 22], # Pão integral

[350, 100, 26], # Pão de forma

[450, 150, 23] # Pão integral

])

y_treino = np.array(['francês', 'forma', 'integral', 'forma', 'integral'])

# Criando e treinando nosso KNN matemático

knn = KNNMatematica(k=3)

knn.fit(X_treino, y_treino)

# Novo pão para classificar

novo_pao = np.array([[380, 110, 26]])

previsao = knn.predict(novo_pao)

print(f"O novo pão foi classificado como: {previsao[0]}")

print("Baseado nos cálculos matemáticos de distância e votação dos vizinhos!")

Os detalhes que fazem diferença

Entender a formulação matemática revela insights cruciais sobre o comportamento dos algoritmos. Por exemplo, a função de custo \(J(\theta) = \frac{1}{2m}\sum_{i=1}^{m}(h_\theta(x^{(i)}) – y^{(i)})^2\) na regressão linear mostra explicitamente que estamos minimizando o erro quadrático médio. Contudo, diferentes algoritmos otimizam diferentes funções: SVM maximiza margens, árvores de decisão maximizam ganho de informação. Analogamente importante é compreender as suposições matemáticas por trás de cada algoritmo; violá-las pode levar a resultados enganosos. A regularização, representada por termos como \(\lambda\sum_{j=1}^{n}\theta_j^2\), controla overfitting penalizando coeficientes grandes.

Funções de custo: Definem o que o algoritmo está tentando otimizar

Gradientes: Direcionam o aprendizado mostrando a direção de melhoria

Regularização: Controla complexidade e previne overfitting

Probabilidades: Fundamentam classificadores como Naive Bayes

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Preciso ser um gênio da matemática para usar machine learning?” Não necessariamente! Você pode usar bibliotecas sem entender toda a matemática, mas compreender os fundamentos torna você muito mais eficaz. Uma confusão comum é entre a formulação teórica e a implementação prática – a teoria assume condições ideais que raramente encontramos em dados reais. Outra dúvida frequente: “Por que tantos algoritmos usam cálculo e álgebra linear?” Porque essas ferramentas matemáticas são perfeitas para otimização em espaços multidimensionais, que é exatamente o que fazemos em machine learning.

Para onde ir agora?

Comece implementando versões simples dos algoritmos do zero, como fizemos com o KNN. Estude uma fórmula por vez, relacionando-a com o comportamento observado nos dados. Use visualizações para conectar conceitos abstratos com resultados concretos. O momento “aha!” acontece quando você consegue prever como um algoritmo se comportará apenas olhando para sua formulação matemática.

Assuntos relacionados

Para dominar as formulações matemáticas, estude estas áreas fundamentais:

Cálculo: derivadas, gradientes e otimização

Álgebra linear: espaços vetoriais, autovalores e decomposições

Probabilidade e estatística: distribuições, verossimilhança e inferência

Teoria da informação: entropia e ganho de informação

Otimização convexa: métodos para encontrar mínimos globais

Referências que valem a pena

Medindo distâncias inteligentes: como a distância de Mahalanobis vê o que outras métricas ignoram

Como isso funciona na prática?

Mãos na massa: implementando a distância de Mahalanobis no Scikit-Learn

Os detalhes que fazem diferença

Perguntas que os iniciantes fazem

Para onde ir agora?

Assuntos relacionados

Referências que valem a pena

A matemática por trás da magia: desvendando as fórmulas dos algoritmos de machine learning

Como isso funciona na prática?

Mãos na massa: implementando a matemática do KNN

Os detalhes que fazem diferença

Perguntas que os iniciantes fazem

Para onde ir agora?

Assuntos relacionados

Referências que valem a pena