LDA na prática: redução de dimensionalidade com um dataset de imóveis

Por que o LDA importa agora

Modelos de linguagem gigantes dominam as manchetes, mas uma parte enorme do trabalho real em ciência de dados ainda acontece na etapa de preparação dos dados — antes mesmo de qualquer rede neural entrar em cena. É aí que técnicas clássicas de redução de dimensionalidade, como a Análise Discriminante Linear (LDA), seguem fazendo a diferença.

Em 2026, com datasets cada vez maiores e o custo de processamento subindo, saber reduzir centenas ou milhares de features para um punhado de componentes interpretáveis é uma habilidade que economiza tempo, dinheiro e poder computacional. Este tutorial mostra como usar o LDA na prática, com um dataset real de imóveis e o Scikit-learn.

O que é LDA

A Análise Discriminante Linear é uma técnica supervisionada usada para reduzir a dimensionalidade de um dataset e, ao mesmo tempo, destacar as características que melhor separam as suas classes. Na literatura, ela também aparece como “Normal Discriminant Analysis” ou “Fisher Linear Discriminant Analysis”, em referência a Ronald A. Fisher, o matemático que desenvolveu o critério que o LDA maximiza.

O critério de Fisher busca a razão entre a variância entre classes (quanto as classes se afastam) e a variância dentro das classes (quanto os pontos da mesma classe se espalham). O objetivo é encontrar combinações lineares das features que maximizem essa separação.

Uma analogia útil: pense em uma peça musical complexa com dezenas de instrumentos. Convertê-la para MIDI reduz brutalmente a quantidade de informação, mas a melodia — as características centrais — continua lá. O LDA faz algo parecido com os dados.

As três premissas do LDA

Antes de aplicar, é preciso saber que o LDA parte de três suposições sobre os dados:

• Linearmente separável — as fronteiras entre as classes são linhas (não curvas). O LDA falha em capturar relações não lineares e estruturas de manifold.
• Distribuição gaussiana — os dados de cada classe seguem uma distribuição normal.
• Covariância compartilhada — todas as classes têm a mesma matriz de covariância, o que permite usar uma matriz “agrupada” (pooled).

Se essas premissas não forem atendidas, o LDA ainda roda, mas os discriminantes podem não ser a melhor representação das características dos dados.

✅ O que você ganha

• Menos custo computacional — operações de matriz em um espaço 2D ou 3D são muito mais baratas do que em um espaço de milhares de dimensões.
• Remoção de features redundantes — o algoritmo dá peso baixo (ou zero) a variáveis que não ajudam a separar as classes.
• Menos overfitting — ao eliminar ruído e correlações espúrias, o modelo fica menos propenso a decorar o dataset.
• Visualização e interpretabilidade — como os discriminantes são combinações lineares das features originais, dá para mapear exatamente o que cada variável contribui.
• Base para classificação — o LDA também funciona como classificador, aproximando o classificador de Bayes.

⚠️ O que você NÃO ganha

• Não lida bem com dados não lineares — para fronteiras curvas, prefira técnicas como kernel PCA ou métodos de manifold learning.
• Não é robusto a dados ruidosos ou esparsos — a suposição gaussiana e de linearidade cobra seu preço.
• Sofre com alta dimensionalidade extrema — quando o número de features é muito maior que o de observações, a estimativa da matriz de covariância tem variância alta e degrada o desempenho.

Pré-requisitos

Passo a passo

1. Entenda o problema

Uma corretora de imóveis quer entender o que realmente distingue os imóveis que ela vende. O dataset tem 17 features (metragem, número de quartos, banheiros, garagem, distância até a escola mais próxima, entre outras) e um rótulo property_type com três classes: apartment (apartamento), condo (condomínio) e single_family_house (casa).

Com 17 features, é impossível visualizar diretamente como os dados se distribuem entre as três classes. É aí que o LDA entra: ele projeta os dados em poucos componentes que preservam a separação entre as classes.

2. Carregue e prepare os dados

import pandas as pd
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.preprocessing import StandardScaler

# Carregar o dataset de imóveis
dataset_df = pd.read_csv("dataset.csv")

# Separar features (X) e rótulo (y)
y = dataset_df["property_type"]
X = dataset_df.drop(columns=["property_type"]).to_numpy()
feature_names = dataset_df.drop(columns=["property_type"]).columns
target_names = y.unique()

# Normalizar as features para que fiquem na mesma escala
X = StandardScaler().fit_transform(X)

O StandardScaler coloca todas as features na mesma escala (média zero, desvio padrão um). Isso não altera o resultado do LDA, mas facilita a visualização da matriz de covariância, já que os valores ficam comparáveis.

3. Aplique o LDA

# Aplicar LDA com 2 componentes (número máximo de classes - 1)
clf = LinearDiscriminantAnalysis(n_components=2, solver="eigen")
clf.fit(X, y)

# Ver a variância explicada por cada componente
print(clf.explained_variance_ratio_)

O número máximo de discriminantes lineares é o mínimo entre (número de features) e (número de classes − 1). Com 3 classes, o máximo é 2 componentes — por isso n_components=2. O parâmetro solver="eigen" usa decomposição de autovetores, o que nos dá acesso ao atributo scalings_ para interpretar a contribuição de cada feature.

O atributo explained_variance_ratio_ mostra quanto da separação entre classes cada componente explica. No exemplo, o primeiro discriminante explica cerca de 90% da separação.

4. Visualize a separação entre classes

import matplotlib.pyplot as plt

# Cores consistentes para cada tipo de imóvel
property_colors = {
    "apartment": "#4C72B0",
    "condo": "#DD8452",
    "single_family_house": "#55A868",
}

def plot_components(X_lda, y, target_names):
    plt.figure(figsize=(10, 7))
    for target_name in target_names:
        mask = y == target_name
        plt.scatter(
            X_lda[mask, 0], X_lda[mask, 1],
            c=property_colors[target_name], label=target_name, alpha=0.7
        )
    plt.xlabel("LD1")
    plt.ylabel("LD2")
    plt.legend()
    plt.title("LDA: separação entre classes")
    plt.show()

# Transformar os dados para o espaço LDA e plotar
X_lda = clf.transform(X)
plot_components(X_lda, y, target_names)

O resultado mostra que apartamentos e casas ficam bem separados, enquanto os condomínios estão mais próximos das casas do que dos apartamentos. Antes do LDA, essa visualização era impossível com 17 features.

5. Descubra quais features mais importam

import seaborn as sns

def plot_class_separation_features(clf, feature_names):
    scalings = clf.scalings_[:, :clf.n_components]
    sns.heatmap(
        scalings, cmap="viridis_r", annot=True, fmt=".2f",
        xticklabels=["LD1", "LD2"], yticklabels=feature_names
    )
    plt.title("Contribuição de cada feature por discriminante")
    plt.show()

plot_class_separation_features(clf, feature_names)

O atributo scalings_ guarda os autovetores. Normalizando cada coluna para somar 100%, você consegue ranquear as features. No exemplo, bedrooms (quartos), garage (garagem) e laundry_hookups (área de serviço) aparecem como as que mais contribuem para separar as classes — uma resposta direta e interpretável para a pergunta da corretora.

LDA vs PCA: qual escolher

Regra prática: se você tem rótulos e quer separar classes ou reduzir features para um classificador, use LDA. Se quer apenas comprimir dados ou explorar a estrutura sem rótulos, use PCA.

Casos de uso reais

• Classificação de imagens — datasets de imagens têm milhares de pixels (features); o LDA reduz esse espaço antes de um classificador. É um dos usos clássicos da técnica.
• Detecção de fraude — separar transações legítimas de fraudulentas em um espaço reduzido e interpretável.
• Bioinformática e genômica — reduzir a expressão de milhares de genes a poucos componentes antes de classificar amostras (ex: tipos de tumor).
• Segmentação de clientes em CRM — entender quais variáveis (renda, frequência de compra, região) mais distinguem grupos de clientes.
• Diagnóstico médico assistido — auxiliar na separação de classes de exames (ex: benigno vs maligno) com componentes interpretáveis para os médicos.

Comparação de custo

Troubleshooting

• ❌ “Variables are collinear” — o LDA detectou features altamente correlacionadas. Causa: colunas redundantes. Solução: remova features correlacionadas ou use PCA antes do LDA.
• ❌ Precisão de 100% no treino — parece ótimo, mas é sinal de overfitting. Causa: poucos dados ou separação trivial. Solução: valide com cross-validation e teste em dados não vistos.
• ❌ Gráfico de classes sobrepostas — as classes não aparecem separadas no plot. Causa: dados não lineares ou premissa gaussiana violada. Solução: experimente técnicas não lineares (kernel PCA, UMAP, t-SNE).
• ❌ explained_variance_ratio_ não soma 1 — normal quando há mais classes que componentes; o atributo reflete apenas os componentes escolhidos. Solução: confira n_components e lembre que o máximo é (classes − 1).
• ❌ Valores de scalings_ difíceis de ler — a escala bruta dos autovetores confunde. Solução: normalize cada coluna para somar 100% antes de ranquear as features.

FAQ

• LDA é só para classificação? Não. Ele também é uma técnica de redução de dimensionalidade para preparar dados, além de poder atuar como classificador.
• Preciso dividir em treino e teste? Depende do objetivo. Se o foco é apenas visualizar e interpretar os dados (como no exemplo), não. Se for prever classes novas, sim.
• LDA substitui o PCA? Não. Eles têm objetivos diferentes. LDA usa rótulos e busca separação de classes; PCA ignora rótulos e busca variância máxima.
• Posso usar LDA com dados não gaussianos? Tecnicamente sim, mas os resultados podem ser subótimos, já que a técnica assume distribuição normal.
• Qual o número máximo de componentes? O mínimo entre o número de features e (número de classes − 1).

O futuro da redução de dimensionalidade

O LDA nasceu nos anos 1930 e segue relevante porque resolve um problema eterno: como enxergar e processar dados de alta dimensão sem perder o que importa. Com a explosão de modelos cada vez maiores, a capacidade de reduzir features de forma interpretável — e barata — continua sendo uma vantagem competitiva real. Em 2027, espere ver o LDA (e suas variantes modernas) ainda mais integrado a pipelines automatizados de machine learning, como etapa padrão antes da classificação.