Arquivo de lda - Área de Trampo

Análise Discriminante: Formulação Matemática dos Classificadores LDA e QDA

19/12/202518/10/2025 Por antonino

Após explorarmos as aplicações práticas da Análise Discriminante, mergulhemos agora nos fundamentos matemáticos que sustentam os classificadores LDA e QDA. Primordialmente, compreender estas formulações nos permitirá aplicar estas técnicas com maior discernimento e interpretar seus resultados de forma mais profunda.

Pressupostos Fundamentais

Conforme mencionamos anteriormente, ambos os métodos assumem que os dados seguem distribuições Gaussianas multivariadas. Analogamente, podemos expressar esta suposição formalmente:

\(P(x | y = k) = \frac{1}{(2\pi)^{d/2} |\Sigma_k|^{1/2}} \exp\left(-\frac{1}{2} (x – \mu_k)^T \Sigma_k^{-1} (x – \mu_k)\right)\)

Onde para cada classe k:

μ_k é o vetor de médias
Σ_k é a matriz de covariância
d é a dimensionalidade dos dados

Teorema de Bayes e Função Discriminante

A decisão de classificação baseia-se no teorema de Bayes:

\(P(y = k | x) = \frac{P(x | y = k) P(y = k)}{P(x)}\)

Como P(x) é constante para todas as classes, maximizar P(y=k|x) equivale a maximizar o numerador. Portanto, definimos a função discriminante como:

\(\delta_k(x) = \log P(x | y = k) + \log P(y = k)\)

Análise Discriminante Linear (LDA)

Pressuposto de Covariância Comum

O LDA assume que todas as classes compartilham a mesma matriz de covariância:

\(\Sigma_k = \Sigma \quad \text{para todo } k\)

Desenvolvendo a função discriminante com este pressuposto, obtemos:

\(\delta_k(x) = x^T \Sigma^{-1} \mu_k – \frac{1}{2} \mu_k^T \Sigma^{-1} \mu_k + \log \pi_k\)

Onde π_k = P(y=k) é a probabilidade a priori da classe k.

Forma Linear da Fronteira de Decisão

A fronteira entre duas classes i e j é determinada por:

\(\delta_i(x) = \delta_j(x)\)

O que resulta em uma equação linear em x:

\(x^T \Sigma^{-1} (\mu_i – \mu_j) – \frac{1}{2} (\mu_i + \mu_j)^T \Sigma^{-1} (\mu_i – \mu_j) + \log(\pi_i/\pi_j) = 0\)

Análise Discriminante Quadrática (QDA)

Matrizes de Covariância Distintas

O QDA permite que cada classe tenha sua própria matriz de covariância:

\(\Sigma_k \neq \Sigma_j \quad \text{para } k \neq j\)

Desenvolvendo a função discriminante, obtemos:

\(\delta_k(x) = -\frac{1}{2} \log |\Sigma_k| – \frac{1}{2} (x – \mu_k)^T \Sigma_k^{-1} (x – \mu_k) + \log \pi_k\)

Forma Quadrática da Fronteira de Decisão

A fronteira entre classes i e j é dada por:

\(\delta_i(x) = \delta_j(x)\)

O que resulta em uma equação quadrática em x, criando fronteiras de decisão curvas.

Estimativa dos Parâmetros

Estimativas de Máxima Verossimilhança

Os parâmetros são estimados a partir dos dados de treinamento:

Médias das classes: \(\hat{\mu}_k = \frac{1}{N_k} \sum_{i: y_i = k} x_i\)
Probabilidades a priori: \(\hat{\pi}_k = \frac{N_k}{N}\)
Matriz de covariância (LDA): \(\hat{\Sigma} = \frac{1}{N-K} \sum_{k=1}^K \sum_{i: y_i = k} (x_i – \hat{\mu}_k)(x_i – \hat{\mu}_k)^T\)
Matrizes de covariância (QDA): \(\hat{\Sigma}_k = \frac{1}{N_k-1} \sum_{i: y_i = k} (x_i – \hat{\mu}_k)(x_i – \hat{\mu}_k)^T\)

Comparação Matemática Detalhada

Complexidade de Parâmetros

O número de parâmetros a estimar difere significativamente:

LDA: K × d (médias) + d(d+1)/2 (covariância) + K (priors)
QDA: K × d (médias) + K × d(d+1)/2 (covariâncias) + K (priors)

Inegavelmente, o QDA requer substancialmente mais parâmetros, especialmente quando o número de features é grande.

Propriedades Estatísticas

Ambos os métodos possuem propriedades interessantes:

São classificadores Bayes ótimos sob os pressupostos Gaussianos
Produzem estimativas de probabilidade posteriores
Podem ser regularizados para melhor generalização
São consistentes sob condições apropriadas

Exemplo Prático em Python

Para ilustrar estas formulações matemáticas, implementemos um exemplo que demonstra os cálculos fundamentais:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis, QuadraticDiscriminantAnalysis
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix
import scipy.stats as stats

'''
Implementação manual dos cálculos LDA e QDA para demonstrar
as formulações matemáticas discutidas
'''

class ManualLDA:
    '''Implementação manual do LDA para fins educacionais'''
    
    def fit(self, X, y):
        """
        Estima os parâmetros do LDA: médias, covariância comum e priors
        """
        self.classes_ = np.unique(y)
        self.n_classes = len(self.classes_)
        self.n_features = X.shape[1]
        
        # Calculando médias por classe
        self.means_ = []
        for k in self.classes_:
            class_mask = (y == k)
            self.means_.append(np.mean(X[class_mask], axis=0))
        self.means_ = np.array(self.means_)
        
        # Calculando probabilidades a priori
        self.priors_ = []
        for k in self.classes_:
            self.priors_.append(np.mean(y == k))
        self.priors_ = np.array(self.priors_)
        
        # Calculando matriz de covariância comum
        self.covariance_ = np.zeros((self.n_features, self.n_features))
        for k, mean in zip(self.classes_, self.means_):
            class_mask = (y == k)
            X_centered = X[class_mask] - mean
            self.covariance_ += X_centered.T @ X_centered
        self.covariance_ /= (len(y) - self.n_classes)
        
        # Pré-calculando a inversa da covariância
        self.covariance_inv_ = np.linalg.pinv(self.covariance_)
        
        return self
    
    def _discriminant_function(self, x, k):
        """
        Calcula a função discriminante para uma observação x e classe k
        δ_k(x) = x^T Σ^{-1} μ_k - 1/2 μ_k^T Σ^{-1} μ_k + log(π_k)
        """
        mean_k = self.means_[k]
        prior_k = self.priors_[k]
        
        linear_term = x @ self.covariance_inv_ @ mean_k
        quadratic_term = 0.5 * mean_k @ self.covariance_inv_ @ mean_k
        prior_term = np.log(prior_k)
        
        return linear_term - quadratic_term + prior_term
    
    def predict_proba(self, X):
        """
        Calcula probabilidades posteriores usando softmax nas funções discriminantes
        """
        n_samples = X.shape[0]
        discriminant_scores = np.zeros((n_samples, self.n_classes))
        
        for k in range(self.n_classes):
            for i in range(n_samples):
                discriminant_scores[i, k] = self._discriminant_function(X[i], k)
        
        # Aplicando softmax para obter probabilidades
        exp_scores = np.exp(discriminant_scores - np.max(discriminant_scores, axis=1, keepdims=True))
        probabilities = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
        
        return probabilities
    
    def predict(self, X):
        """
        Prediz classes selecionando a com maior probabilidade posterior
        """
        probabilities = self.predict_proba(X)
        return np.argmax(probabilities, axis=1)

'''
Demonstração comparativa entre implementação manual e scikit-learn
'''
print("=== DEMONSTRAÇÃO DAS FORMULAÇÕES MATEMÁTICAS ===")

# Gerando dados de exemplo
X, y = make_classification(
    n_samples=300, n_features=2, n_informative=2, n_redundant=0,
    n_classes=3, n_clusters_per_class=1, random_state=42
)

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

# Aplicando implementação manual
print("\n1. IMPLEMENTAÇÃO MANUAL DO LDA")
manual_lda = ManualLDA()
manual_lda.fit(X_train, y_train)
y_pred_manual = manual_lda.predict(X_test)
accuracy_manual = accuracy_score(y_test, y_pred_manual)

print(f"Parâmetros estimados:")
print(f"  - Médias das classes: {manual_lda.means_.shape}")
print(f"  - Matriz de covariância: {manual_lda.covariance_.shape}")
print(f"  - Priors: {manual_lda.priors_}")
print(f"  - Acurácia (manual): {accuracy_manual:.3f}")

# Comparando com scikit-learn
print("\n2. COMPARAÇÃO COM SCIKIT-LEARN")
sklearn_lda = LinearDiscriminantAnalysis()
sklearn_lda.fit(X_train, y_train)
y_pred_sklearn = sklearn_lda.predict(X_test)
accuracy_sklearn = accuracy_score(y_test, y_pred_sklearn)

print(f"  - Acurácia (scikit-learn): {accuracy_sklearn:.3f}")
print(f"  - Coincidência nas predições: {np.mean(y_pred_manual == y_pred_sklearn):.3f}")

'''
Análise das funções discriminantes para uma observação específica
'''
print("\n3. ANÁLISE DAS FUNÇÕES DISCRIMINANTES")
sample_idx = 0
x_sample = X_test[sample_idx]
true_class = y_test[sample_idx]

print(f"Observação de teste {sample_idx}:")
print(f"  - Classe verdadeira: {true_class}")

# Calculando scores discriminantes manualmente
for k in range(manual_lda.n_classes):
    score = manual_lda._discriminant_function(x_sample, k)
    print(f"  - Score classe {k}: {score:.3f}")

# Probabilidades calculadas manualmente
proba_manual = manual_lda.predict_proba(X_test[sample_idx:sample_idx+1])[0]
print(f"  - Probabilidades (manual): {proba_manual}")

# Probabilidades do scikit-learn
proba_sklearn = sklearn_lda.predict_proba(X_test[sample_idx:sample_idx+1])[0]
print(f"  - Probabilidades (scikit-learn): {proba_sklearn}")

'''
Visualização das fronteiras de decisão
'''
print("\n4. VISUALIZAÇÃO DAS FRONTEIRAS DE DECISÃO")

# Criando grid para plotar fronteiras
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))

# Plot implementação manual
Z_manual = manual_lda.predict(np.c_[xx.ravel(), yy.ravel()])
Z_manual = Z_manual.reshape(xx.shape)
contour1 = ax1.contourf(xx, yy, Z_manual, alpha=0.3, cmap=plt.cm.Paired)
scatter1 = ax1.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=plt.cm.Paired, edgecolors='k')
ax1.set_title('Fronteiras de Decisão - Implementação Manual')
ax1.set_xlabel('Feature 1')
ax1.set_ylabel('Feature 2')

# Plot scikit-learn
Z_sklearn = sklearn_lda.predict(np.c_[xx.ravel(), yy.ravel()])
Z_sklearn = Z_sklearn.reshape(xx.shape)
contour2 = ax2.contourf(xx, yy, Z_sklearn, alpha=0.3, cmap=plt.cm.Paired)
scatter2 = ax2.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=plt.cm.Paired, edgecolors='k')
ax2.set_title('Fronteiras de Decisão - Scikit-learn')
ax2.set_xlabel('Feature 1')
ax2.set_ylabel('Feature 2')

plt.tight_layout()
plt.show()

'''
Demonstração do cálculo da matriz de covariância
'''
print("\n5. CÁLCULO DETALHADO DA MATRIZ DE COVARIÂNCIA")
print("Matriz de covariância comum (LDA):")
print(manual_lda.covariance_)

# Verificando cálculo manual vs numpy
cov_numpy = np.cov(X_train.T, bias=True)
print("\nVerificação com numpy.cov (com bias adjustment):")
print("Diferença máxima:", np.max(np.abs(manual_lda.covariance_ - cov_numpy)))

'''
Implementação simplificada do QDA para comparação
'''
print("\n6. COMPARAÇÃO COM QDA")

sklearn_qda = QuadraticDiscriminantAnalysis()
sklearn_qda.fit(X_train, y_train)
y_pred_qda = sklearn_qda.predict(X_test)
accuracy_qda = accuracy_score(y_test, y_pred_qda)

print(f"  - Acurácia QDA: {accuracy_qda:.3f}")
print(f"  - Acurácia LDA: {accuracy_sklearn:.3f}")

# Analisando diferenças nas predições
diff_lda_qda = np.mean(y_pred_sklearn != y_pred_qda)
print(f"  - Diferença nas predições LDA vs QDA: {diff_lda_qda:.3f}")

'''
Interpretação dos resultados matemáticos
'''
print("\n7. INTERPRETAÇÃO MATEMÁTICA")
print("Os resultados demonstram que:")
print("  - As formulações matemáticas produzem classificadores consistentes")
print("  - A implementação manual coincide com o scikit-learn")
print("  - As funções discriminantes capturam a informação de classe")
print("  - As fronteiras de decisão refletem a estrutura linear do LDA")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

import numpy as np

import matplotlib.pyplot as plt

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis, QuadraticDiscriminantAnalysis

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score, confusion_matrix

import scipy.stats as stats

'''

Implementação manual dos cálculos LDA e QDA para demonstrar

as formulações matemáticas discutidas

'''

class ManualLDA:

'''Implementação manual do LDA para fins educacionais'''

def fit(self, X, y):

"""

Estima os parâmetros do LDA: médias, covariância comum e priors

"""

self.classes_ = np.unique(y)

self.n_classes = len(self.classes_)

self.n_features = X.shape[1]

# Calculando médias por classe

self.means_ = []

for k in self.classes_:

class_mask = (y == k)

self.means_.append(np.mean(X[class_mask], axis=0))

self.means_ = np.array(self.means_)

# Calculando probabilidades a priori

self.priors_ = []

for k in self.classes_:

self.priors_.append(np.mean(y == k))

self.priors_ = np.array(self.priors_)

# Calculando matriz de covariância comum

self.covariance_ = np.zeros((self.n_features, self.n_features))

for k, mean in zip(self.classes_, self.means_):

class_mask = (y == k)

X_centered = X[class_mask] - mean

self.covariance_ += X_centered.T @ X_centered

self.covariance_ /= (len(y) - self.n_classes)

# Pré-calculando a inversa da covariância

self.covariance_inv_ = np.linalg.pinv(self.covariance_)

return self

def _discriminant_function(self, x, k):

"""

Calcula a função discriminante para uma observação x e classe k

δ_k(x) = x^T Σ^{-1} μ_k - 1/2 μ_k^T Σ^{-1} μ_k + log(π_k)

"""

mean_k = self.means_[k]

prior_k = self.priors_[k]

linear_term = x @ self.covariance_inv_ @ mean_k

quadratic_term = 0.5 * mean_k @ self.covariance_inv_ @ mean_k

prior_term = np.log(prior_k)

return linear_term - quadratic_term + prior_term

def predict_proba(self, X):

"""

Calcula probabilidades posteriores usando softmax nas funções discriminantes

"""

n_samples = X.shape[0]

discriminant_scores = np.zeros((n_samples, self.n_classes))

for k in range(self.n_classes):

for i in range(n_samples):

discriminant_scores[i, k] = self._discriminant_function(X[i], k)

# Aplicando softmax para obter probabilidades

exp_scores = np.exp(discriminant_scores - np.max(discriminant_scores, axis=1, keepdims=True))

probabilities = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)

return probabilities

def predict(self, X):

"""

Prediz classes selecionando a com maior probabilidade posterior

"""

probabilities = self.predict_proba(X)

return np.argmax(probabilities, axis=1)

'''

Demonstração comparativa entre implementação manual e scikit-learn

'''

print("=== DEMONSTRAÇÃO DAS FORMULAÇÕES MATEMÁTICAS ===")

# Gerando dados de exemplo

X, y = make_classification(

n_samples=300, n_features=2, n_informative=2, n_redundant=0,

n_classes=3, n_clusters_per_class=1, random_state=42

)

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

# Aplicando implementação manual

print("\n1. IMPLEMENTAÇÃO MANUAL DO LDA")

manual_lda = ManualLDA()

manual_lda.fit(X_train, y_train)

y_pred_manual = manual_lda.predict(X_test)

accuracy_manual = accuracy_score(y_test, y_pred_manual)

print(f"Parâmetros estimados:")

print(f" - Médias das classes: {manual_lda.means_.shape}")

print(f" - Matriz de covariância: {manual_lda.covariance_.shape}")

print(f" - Priors: {manual_lda.priors_}")

print(f" - Acurácia (manual): {accuracy_manual:.3f}")

# Comparando com scikit-learn

print("\n2. COMPARAÇÃO COM SCIKIT-LEARN")

sklearn_lda = LinearDiscriminantAnalysis()

sklearn_lda.fit(X_train, y_train)

y_pred_sklearn = sklearn_lda.predict(X_test)

accuracy_sklearn = accuracy_score(y_test, y_pred_sklearn)

print(f" - Acurácia (scikit-learn): {accuracy_sklearn:.3f}")

print(f" - Coincidência nas predições: {np.mean(y_pred_manual == y_pred_sklearn):.3f}")

'''

Análise das funções discriminantes para uma observação específica

'''

print("\n3. ANÁLISE DAS FUNÇÕES DISCRIMINANTES")

sample_idx = 0

x_sample = X_test[sample_idx]

true_class = y_test[sample_idx]

print(f"Observação de teste {sample_idx}:")

print(f" - Classe verdadeira: {true_class}")

# Calculando scores discriminantes manualmente

for k in range(manual_lda.n_classes):

score = manual_lda._discriminant_function(x_sample, k)

print(f" - Score classe {k}: {score:.3f}")

# Probabilidades calculadas manualmente

proba_manual = manual_lda.predict_proba(X_test[sample_idx:sample_idx+1])[0]

print(f" - Probabilidades (manual): {proba_manual}")

# Probabilidades do scikit-learn

proba_sklearn = sklearn_lda.predict_proba(X_test[sample_idx:sample_idx+1])[0]

print(f" - Probabilidades (scikit-learn): {proba_sklearn}")

'''

Visualização das fronteiras de decisão

'''

print("\n4. VISUALIZAÇÃO DAS FRONTEIRAS DE DECISÃO")

# Criando grid para plotar fronteiras

h = 0.02

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1

y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1

xx, yy = np.meshgrid(np.arange(x_min, x_max, h),

np.arange(y_min, y_max, h))

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))

# Plot implementação manual

Z_manual = manual_lda.predict(np.c_[xx.ravel(), yy.ravel()])

Z_manual = Z_manual.reshape(xx.shape)

contour1 = ax1.contourf(xx, yy, Z_manual, alpha=0.3, cmap=plt.cm.Paired)

scatter1 = ax1.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=plt.cm.Paired, edgecolors='k')

ax1.set_title('Fronteiras de Decisão - Implementação Manual')

ax1.set_xlabel('Feature 1')

ax1.set_ylabel('Feature 2')

# Plot scikit-learn

Z_sklearn = sklearn_lda.predict(np.c_[xx.ravel(), yy.ravel()])

Z_sklearn = Z_sklearn.reshape(xx.shape)

contour2 = ax2.contourf(xx, yy, Z_sklearn, alpha=0.3, cmap=plt.cm.Paired)

scatter2 = ax2.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=plt.cm.Paired, edgecolors='k')

ax2.set_title('Fronteiras de Decisão - Scikit-learn')

ax2.set_xlabel('Feature 1')

ax2.set_ylabel('Feature 2')

plt.tight_layout()

plt.show()

'''

Demonstração do cálculo da matriz de covariância

'''

print("\n5. CÁLCULO DETALHADO DA MATRIZ DE COVARIÂNCIA")

print("Matriz de covariância comum (LDA):")

print(manual_lda.covariance_)

# Verificando cálculo manual vs numpy

cov_numpy = np.cov(X_train.T, bias=True)

print("\nVerificação com numpy.cov (com bias adjustment):")

print("Diferença máxima:", np.max(np.abs(manual_lda.covariance_ - cov_numpy)))

'''

Implementação simplificada do QDA para comparação

'''

print("\n6. COMPARAÇÃO COM QDA")

sklearn_qda = QuadraticDiscriminantAnalysis()

sklearn_qda.fit(X_train, y_train)

y_pred_qda = sklearn_qda.predict(X_test)

accuracy_qda = accuracy_score(y_test, y_pred_qda)

print(f" - Acurácia QDA: {accuracy_qda:.3f}")

print(f" - Acurácia LDA: {accuracy_sklearn:.3f}")

# Analisando diferenças nas predições

diff_lda_qda = np.mean(y_pred_sklearn != y_pred_qda)

print(f" - Diferença nas predições LDA vs QDA: {diff_lda_qda:.3f}")

'''

Interpretação dos resultados matemáticos

'''

print("\n7. INTERPRETAÇÃO MATEMÁTICA")

print("Os resultados demonstram que:")

print(" - As formulações matemáticas produzem classificadores consistentes")

print(" - A implementação manual coincide com o scikit-learn")

print(" - As funções discriminantes capturam a informação de classe")

print(" - As fronteiras de decisão refletem a estrutura linear do LDA")

Interpretação dos Resultados Matemáticos

Analisando a implementação e os resultados, podemos observar que:

As funções discriminantes realmente capturam a informação de separação entre classes
A matriz de covariância comum no LDA produz fronteiras lineares
As probabilidades posteriores são calculadas corretamente via softmax
A implementação manual coincide com a do scikit-learn, validando as formulações

Implicações Práticas das Formulações

Vantagens do LDA

Menos parâmetros para estimar → mais robusto com dados limitados
Computacionalmente mais eficiente
Fronteiras de decisão lineares são mais interpretáveis

Vantagens do QDA

Mais flexibilidade para capturar relações complexas
Melhor performance quando as covariâncias são realmente diferentes
Fronteiras de decisão curvas podem se ajustar melhor aos dados

Considerações Finais

As formulações matemáticas do LDA e QDA revelam por que estas técnicas são tão eficazes sob os pressupostos Gaussianos. Embora baseadas em conceitos estatísticos clássicos, continuam sendo ferramentas valiosas no machine learning moderno.

Portanto, compreender estas fundamentações não apenas nos permite aplicar os métodos corretamente, mas também nos capacita a interpretar seus resultados, diagnosticar problemas e fazer escolhas informadas entre diferentes abordagens de classificação.

Análise Discriminante: Redução de Dimensionalidade usando Análise Discriminante Linear

19/12/202518/10/2025 Por antonino

Continuando nossa exploração da Análise Discriminante Linear, chegamos a uma aplicação particularmente valiosa: a redução de dimensionalidade. Enquanto anteriormente discutimos o LDA como classificador, agora focaremos em sua capacidade de projetar dados em espaços de menor dimensão preservando a separabilidade entre classes.

O Conceito de Redução de Dimensionalidade com LDA

Conforme observamos na seção anterior, o LDA busca encontrar eixos que maximizem a separação entre classes. Analogamente, quando aplicado para redução de dimensionalidade, o LDA identifica as direções que melhor discriminam as classes, projetando os dados em um espaço com dimensionalidade reduzida.

Fundamentos Matemáticos

O LDA para redução de dimensionalidade baseia-se na maximização do critério de Fisher:

\(J(w) = \frac{w^T S_B w}{w^T S_W w}\)

Onde:

S_B é a matriz de dispersão entre classes (between-class scatter)
S_W é a matriz de dispersão dentro das classes (within-class scatter)
w são os vetores de projeção que maximizam a separação

Inegavelmente, esta abordagem encontra automaticamente as direções que preservam a informação mais discriminativa dos dados.

Diferenças entre LDA e PCA

Embora tanto LDA quanto PCA realizem redução de dimensionalidade, seus objetivos fundamentais diferem significativamente:

PCA: Maximiza a variância total dos dados (não supervisionado)
LDA: Maximiza a separação entre classes (supervisionado)

Portanto, o LDA é especialmente útil quando temos labels disponíveis e queremos preservar a estrutura de classes durante a redução de dimensionalidade.

Implementação no scikit-learn

No scikit-learn, a redução de dimensionalidade com LDA é realizada através da mesma classe LinearDiscriminantAnalysis, mas especificando o número de componentes desejado:

O parâmetro n_components controla a dimensionalidade do espaço projetado
O número máximo de componentes é min(n_classes - 1, n_features)
O método transform realiza a projeção dos dados

Vantagens da Abordagem

Preserva a informação discriminativa entre classes
Reduz ruído e redundância nas features
Melhora a performance de classificadores subsequentes
Facilita visualização de dados multivariados

Aplicações Práticas

Primordialmente, a redução de dimensionalidade com LDA é útil em cenários como:

Pré-processamento para outros algoritmos de machine learning
Visualização de dados de alta dimensionalidade
Extração de features para sistemas de reconhecimento
Análise exploratória de dados com labels

Exemplo Prático em Python

Para ilustrar a redução de dimensionalidade com LDA, vejamos um exemplo completo com visualização:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.datasets import load_iris, make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score

'''
Demonstração da redução de dimensionalidade usando LDA
com comparação entre dados originais e projetados
'''

# Carregando dataset Iris como exemplo clássico
iris = load_iris()
X, y = iris.data, iris.target
feature_names = iris.feature_names
target_names = iris.target_names

print("=== INFORMAÇÕES DO DATASET ORIGINAL ===")
print(f"Dimensionalidade original: {X.shape}")
print(f"Número de classes: {len(np.unique(y))}")
print(f"Nomes das classes: {list(target_names)}")
print(f"Features originais: {list(feature_names)}")

'''
Aplicando LDA para redução de dimensionalidade
'''
# Primeiramente, padronizamos os dados
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Aplicando LDA com redução para 2 componentes (máximo possível para 3 classes)
lda = LinearDiscriminantAnalysis(n_components=2)
X_lda = lda.fit_transform(X_scaled, y)

print(f"\n=== REDUÇÃO DE DIMENSIONALIDADE ===")
print(f"Dimensionalidade após LDA: {X_lda.shape}")
print(f"Variância explicada por componente: {lda.explained_variance_ratio_}")
print(f"Variância total explicada: {sum(lda.explained_variance_ratio_):.3f}")

'''
Visualização comparativa: dados originais vs dados projetados
'''
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 5))

# Plot 1: Duas features originais para comparação
for i, target_name in enumerate(target_names):
    ax1.scatter(X_scaled[y == i, 0], X_scaled[y == i, 1], 
                alpha=0.8, label=target_name)
ax1.set_title('Duas Features Originais (Padronizadas)')
ax1.set_xlabel('Comprimento da Sépala (padronizado)')
ax1.set_ylabel('Largura da Sépala (padronizado)')
ax1.legend()
ax1.grid(True, alpha=0.3)

# Plot 2: Projeção LDA
for i, target_name in enumerate(target_names):
    ax2.scatter(X_lda[y == i, 0], X_lda[y == i, 1], 
                alpha=0.8, label=target_name)
ax2.set_title('Projeção LDA (2 Componentes)')
ax2.set_xlabel('Componente LDA 1')
ax2.set_ylabel('Componente LDA 2')
ax2.legend()
ax2.grid(True, alpha=0.3)

# Plot 3: Apenas primeira componente LDA (1D)
for i, target_name in enumerate(target_names):
    ax3.scatter(X_lda[y == i, 0], np.zeros_like(X_lda[y == i, 0]), 
                alpha=0.8, label=target_name)
ax3.set_title('Projeção LDA (1 Componente)')
ax3.set_xlabel('Componente LDA 1')
ax3.set_yticks([])
ax3.legend()
ax3.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

'''
Avaliando o impacto na classificação
'''
print("\n=== IMPACTO NA CLASSIFICAÇÃO ===")

# Dividindo os dados
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.3, random_state=42
)

# Classificador nos dados originais
lda_original = LinearDiscriminantAnalysis()
lda_original.fit(X_train, y_train)
y_pred_original = lda_original.predict(X_test)
accuracy_original = accuracy_score(y_test, y_pred_original)

# Classificador nos dados reduzidos (2 componentes)
X_train_lda = lda.transform(X_train)
X_test_lda = lda.transform(X_test)

lda_reduced = LinearDiscriminantAnalysis()
lda_reduced.fit(X_train_lda, y_train)
y_pred_reduced = lda_reduced.predict(X_test_lda)
accuracy_reduced = accuracy_score(y_test, y_pred_reduced)

print(f"Acurácia com dados originais (4D): {accuracy_original:.3f}")
print(f"Acurácia com dados reduzidos (2D): {accuracy_reduced:.3f}")

'''
Exemplo com dataset de maior dimensionalidade
'''
print("\n=== EXEMPLO COM ALTA DIMENSIONALIDADE ===")

# Criando dataset artificial com mais features
X_high, y_high = make_classification(
    n_samples=200, n_features=20, n_informative=5, 
    n_redundant=10, n_classes=3, random_state=42
)

X_high_scaled = StandardScaler().fit_transform(X_high)

# LDA para redução
lda_high = LinearDiscriminantAnalysis(n_components=2)
X_high_lda = lda_high.fit_transform(X_high_scaled, y_high)

print(f"Dimensionalidade original: {X_high.shape}")
print(f"Dimensionalidade após LDA: {X_high_lda.shape}")

# Visualização da redução de 20D para 2D
plt.figure(figsize=(10, 6))
for i in range(3):
    plt.scatter(X_high_lda[y_high == i, 0], X_high_lda[y_high == i, 1], 
                alpha=0.7, label=f'Classe {i}')
plt.title('Redução LDA: 20D → 2D')
plt.xlabel('Componente LDA 1')
plt.ylabel('Componente LDA 2')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

'''
Análise dos componentes LDA
'''
print("\n=== ANÁLISE DOS COMPONENTES LDA ===")
print("Coeficientes dos componentes LDA (pesos das features originais):")

if hasattr(lda, 'scalings_'):
    for comp_idx in range(lda.scalings_.shape[1]):
        print(f"Componente {comp_idx + 1}:")
        for feat_idx, feat_name in enumerate(feature_names):
            weight = lda.scalings_[feat_idx, comp_idx]
            print(f"  {feat_name}: {weight:.3f}")

'''
Interpretação prática dos resultados
'''
print("\n=== INTERPRETAÇÃO PRÁTICA ===")
print("O LDA para redução de dimensionalidade oferece:")
print("1. Preservação da estrutura de classes em espaço reduzido")
print("2. Componentes que maximizam a separação entre grupos")
print("3. Visualização eficiente de dados multivariados")
print("4. Pré-processamento para algoritmos subsequentes")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

import numpy as np

import matplotlib.pyplot as plt

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

from sklearn.datasets import load_iris, make_classification

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import accuracy_score

'''

Demonstração da redução de dimensionalidade usando LDA

com comparação entre dados originais e projetados

'''

# Carregando dataset Iris como exemplo clássico

iris = load_iris()

X, y = iris.data, iris.target

feature_names = iris.feature_names

target_names = iris.target_names

print("=== INFORMAÇÕES DO DATASET ORIGINAL ===")

print(f"Dimensionalidade original: {X.shape}")

print(f"Número de classes: {len(np.unique(y))}")

print(f"Nomes das classes: {list(target_names)}")

print(f"Features originais: {list(feature_names)}")

'''

Aplicando LDA para redução de dimensionalidade

'''

# Primeiramente, padronizamos os dados

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

# Aplicando LDA com redução para 2 componentes (máximo possível para 3 classes)

lda = LinearDiscriminantAnalysis(n_components=2)

X_lda = lda.fit_transform(X_scaled, y)

print(f"\n=== REDUÇÃO DE DIMENSIONALIDADE ===")

print(f"Dimensionalidade após LDA: {X_lda.shape}")

print(f"Variância explicada por componente: {lda.explained_variance_ratio_}")

print(f"Variância total explicada: {sum(lda.explained_variance_ratio_):.3f}")

'''

Visualização comparativa: dados originais vs dados projetados

'''

fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 5))

# Plot 1: Duas features originais para comparação

for i, target_name in enumerate(target_names):

ax1.scatter(X_scaled[y == i, 0], X_scaled[y == i, 1],

alpha=0.8, label=target_name)

ax1.set_title('Duas Features Originais (Padronizadas)')

ax1.set_xlabel('Comprimento da Sépala (padronizado)')

ax1.set_ylabel('Largura da Sépala (padronizado)')

ax1.legend()

ax1.grid(True, alpha=0.3)

# Plot 2: Projeção LDA

for i, target_name in enumerate(target_names):

ax2.scatter(X_lda[y == i, 0], X_lda[y == i, 1],

alpha=0.8, label=target_name)

ax2.set_title('Projeção LDA (2 Componentes)')

ax2.set_xlabel('Componente LDA 1')

ax2.set_ylabel('Componente LDA 2')

ax2.legend()

ax2.grid(True, alpha=0.3)

# Plot 3: Apenas primeira componente LDA (1D)

for i, target_name in enumerate(target_names):

ax3.scatter(X_lda[y == i, 0], np.zeros_like(X_lda[y == i, 0]),

alpha=0.8, label=target_name)

ax3.set_title('Projeção LDA (1 Componente)')

ax3.set_xlabel('Componente LDA 1')

ax3.set_yticks([])

ax3.legend()

ax3.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

'''

Avaliando o impacto na classificação

'''

print("\n=== IMPACTO NA CLASSIFICAÇÃO ===")

# Dividindo os dados

X_train, X_test, y_train, y_test = train_test_split(

X_scaled, y, test_size=0.3, random_state=42

)

# Classificador nos dados originais

lda_original = LinearDiscriminantAnalysis()

lda_original.fit(X_train, y_train)

y_pred_original = lda_original.predict(X_test)

accuracy_original = accuracy_score(y_test, y_pred_original)

# Classificador nos dados reduzidos (2 componentes)

X_train_lda = lda.transform(X_train)

X_test_lda = lda.transform(X_test)

lda_reduced = LinearDiscriminantAnalysis()

lda_reduced.fit(X_train_lda, y_train)

y_pred_reduced = lda_reduced.predict(X_test_lda)

accuracy_reduced = accuracy_score(y_test, y_pred_reduced)

print(f"Acurácia com dados originais (4D): {accuracy_original:.3f}")

print(f"Acurácia com dados reduzidos (2D): {accuracy_reduced:.3f}")

'''

Exemplo com dataset de maior dimensionalidade

'''

print("\n=== EXEMPLO COM ALTA DIMENSIONALIDADE ===")

# Criando dataset artificial com mais features

X_high, y_high = make_classification(

n_samples=200, n_features=20, n_informative=5,

n_redundant=10, n_classes=3, random_state=42

)

X_high_scaled = StandardScaler().fit_transform(X_high)

# LDA para redução

lda_high = LinearDiscriminantAnalysis(n_components=2)

X_high_lda = lda_high.fit_transform(X_high_scaled, y_high)

print(f"Dimensionalidade original: {X_high.shape}")

print(f"Dimensionalidade após LDA: {X_high_lda.shape}")

# Visualização da redução de 20D para 2D

plt.figure(figsize=(10, 6))

for i in range(3):

plt.scatter(X_high_lda[y_high == i, 0], X_high_lda[y_high == i, 1],

alpha=0.7, label=f'Classe {i}')

plt.title('Redução LDA: 20D → 2D')

plt.xlabel('Componente LDA 1')

plt.ylabel('Componente LDA 2')

plt.legend()

plt.grid(True, alpha=0.3)

plt.show()

'''

Análise dos componentes LDA

'''

print("\n=== ANÁLISE DOS COMPONENTES LDA ===")

print("Coeficientes dos componentes LDA (pesos das features originais):")

if hasattr(lda, 'scalings_'):

for comp_idx in range(lda.scalings_.shape[1]):

print(f"Componente {comp_idx + 1}:")

for feat_idx, feat_name in enumerate(feature_names):

weight = lda.scalings_[feat_idx, comp_idx]

print(f" {feat_name}: {weight:.3f}")

'''

Interpretação prática dos resultados

'''

print("\n=== INTERPRETAÇÃO PRÁTICA ===")

print("O LDA para redução de dimensionalidade oferece:")

print("1. Preservação da estrutura de classes em espaço reduzido")

print("2. Componentes que maximizam a separação entre grupos")

print("3. Visualização eficiente de dados multivariados")

print("4. Pré-processamento para algoritmos subsequentes")

Interpretação dos Resultados

Analisando o exemplo, podemos observar que:

O LDA consegue reduzir significativamente a dimensionalidade mantendo a separabilidade
Os componentes LDA capturam direções que maximizam a distância entre classes
Mesmo com redução drástica (de 20D para 2D), a estrutura discriminativa é preservada
A performance de classificação pode ser mantida ou mesmo melhorada com a redução

Considerações Importantes

Limitações do LDA

Embora poderoso, o LDA para redução de dimensionalidade tem algumas limitações:

Assume distribuição normal dos dados
Presume matrizes de covariância iguais entre classes
Número máximo de componentes é limitado pelo número de classes
Sensível a outliers nos dados

Melhores Práticas

Para obter os melhores resultados com LDA:

Sempre padronize os dados antes de aplicar LDA
Verifique os pressupostos quando possível
Use validação cruzada para determinar o número ideal de componentes
Combine com outras técnicas de pré-processamento quando necessário

Aplicações em Cenários Reais

Similarmente às aplicações que discutimos anteriormente, a redução de dimensionalidade com LDA é particularmente útil em:

Reconhecimento facial e biométrica
Análise de expressão gênica
Processamento de sinais médicos
Análise de documentos e texto

Portanto, o LDA representa uma ferramenta valiosa no arsenal de técnicas de redução de dimensionalidade, especialmente quando trabalhamos com dados supervisionados e buscamos preservar a informação discriminativa entre classes. Inclusive, sua combinação com outros métodos pode levar a soluções ainda mais robustas e eficientes.