Arquivo de Inteligência Artificial - Página 150 de 165

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

25/04/202618/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.

Análise Discriminante: Linear e Quadrática

25/04/202618/10/2025 Por antonino

Continuando nossa jornada pelo guia do scikit-learn, chegamos a uma família de classificadores probabilísticos fundamentais: a Análise Discriminante Linear (LDA) e Quadrática (QDA). Primordialmente, estas técnicas representam abordagens elegantes para classificação que combinam princípios estatísticos com eficiência computacional.

Fundamentos Teóricos

Conforme observamos anteriormente com modelos lineares, frequentemente buscamos métodos que ofereçam bom desempenho com interpretabilidade. Analogamente, LDA e QDA surgem como alternativas baseadas em pressupostos sobre a distribuição dos dados.

Pressupostos Básicos

Ambos os métodos assumem que:

Os dados seguem uma distribuição normal
As features são contínuas
As classes têm distribuições Gaussianas multivariadas

A diferença fundamental reside na suposição sobre as matrizes de covariância:

LDA: Matriz de covariância comum para todas as classes
QDA: Matriz de covariância distinta para cada classe

Análise Discriminante Linear (LDA)

Base Matemática

O LDA assume que todas as classes compartilham a mesma matriz de covariância Σ. A função discriminante para a classe k é dada por:

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

Onde:

μ_k é a média da classe k
Σ é a matriz de covariância comum
π_k é a probabilidade a priori da classe k

Características do LDA

Produz fronteiras de decisão lineares
Menos parâmetros para estimar
Mais robusto com poucos dados
Computacionalmente eficiente

Análise Discriminante Quadrática (QDA)

Base Matemática

O QDA permite que cada classe tenha sua própria matriz de covariância Σ_k. A função discriminante torna-se:

\(\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\)

Características do QDA

Produz fronteiras de decisão quadráticas
Mais flexível que o LDA
Requer mais dados para estimação confiável
Pode capturar relações mais complexas entre features

Comparação entre LDA e QDA

A escolha entre LDA e QDA depende de vários fatores:

Tamanho do conjunto de dados
Número de features
Similaridade das matrizes de covariância entre classes
Complexidade das fronteiras de decisão necessárias

Inegavelmente, o LDA é preferível quando temos dados limitados, enquanto o QDA pode oferecer melhor performance quando as matrizes de covariância são realmente diferentes e temos dados suficientes para estimá-las adequadamente.

Implementação no scikit-learn

No scikit-learn, ambas as técnicas são implementadas através das classes:

LinearDiscriminantAnalysis
QuadraticDiscriminantAnalysis

Estas classes oferecem funcionalidades adicionais como redução de dimensionalidade (no caso do LDA) e suporte a diferentes métodos de estimação de parâmetros.

Exemplo Prático em Python

Para ilustrar as diferenças entre LDA e QDA, vejamos um exemplo comparativo:

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

'''
Exemplo comparativo entre LDA e QDA em diferentes cenários
de dados para ilustrar suas características distintas
'''

# Cenário 1: Dados com matrizes de covariância similares
print("=== CENÁRIO 1: Matrizes de Covariância Similares ===")
X1, y1 = make_classification(
    n_samples=300, n_features=2, n_informative=2, n_redundant=0,
    n_clusters_per_class=1, class_sep=2.0, random_state=42
)

# Cenário 2: Dados com matrizes de covariância diferentes
print("=== CENÁRIO 2: Matrizes de Covariância Diferentes ===")
X2, y2 = make_blobs(
    n_samples=300, centers=2, cluster_std=[1.0, 2.5], 
    random_state=42, n_features=2
)

# Transformando para criar covariâncias diferentes
transformation = [[0.6, -0.6], [-0.4, 0.8]]
X2 = np.dot(X2, transformation)

cenarios = [
    ('Covariância Similar', X1, y1),
    ('Covariância Diferente', X2, y2)
]

'''
Configurando os modelos e avaliando em cada cenário
'''
models = {
    'LDA': LinearDiscriminantAnalysis(),
    'QDA': QuadraticDiscriminantAnalysis()
}

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

for cenario_idx, (cenario_nome, X, y) in enumerate(cenarios, 1):
    
    # Dividindo os dados
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=42
    )
    
    # Padronizando os dados
    scaler = StandardScaler()
    X_train_scaled = scaler.fit_transform(X_train)
    X_test_scaled = scaler.transform(X_test)
    
    # Criando mesh para plotar fronteiras de decisão
    h = 0.02
    x_min, x_max = X_train_scaled[:, 0].min() - 1, X_train_scaled[:, 0].max() + 1
    y_min, y_max = X_train_scaled[:, 1].min() - 1, X_train_scaled[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))
    
    for model_idx, (model_name, model) in enumerate(models.items(), 1):
        plt.subplot(2, 2, (cenario_idx - 1) * 2 + model_idx)
        
        # Treinando o modelo
        model.fit(X_train_scaled, y_train)
        
        # Fazendo previsões
        y_pred = model.predict(X_test_scaled)
        accuracy = accuracy_score(y_test, y_pred)
        
        # Plotando fronteira de decisão
        Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
        Z = Z.reshape(xx.shape)
        plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.Paired)
        
        # Plotando dados de treino - CORREÇÃO: removendo parâmetro cmap do scatter
        colors = ['red', 'blue', 'green']
        for class_idx, class_label in enumerate(np.unique(y_train)):
            class_mask = y_train == class_label
            plt.scatter(X_train_scaled[class_mask, 0], X_train_scaled[class_mask, 1],
                       alpha=0.8, label=f'Classe {class_label}', 
                       color=colors[class_idx % len(colors)])
        
        plt.title(f'{cenario_nome}\n{model_name} - Acurácia: {accuracy:.3f}')
        plt.xlabel('Feature 1 (padronizada)')
        plt.ylabel('Feature 2 (padronizada)')
        plt.legend()

plt.tight_layout()
plt.show()

'''
Análise detalhada dos parâmetros dos modelos - VERSÃO CORRIGIDA
'''
print("\n=== ANÁLISE DOS PARÂMETROS ===")

for (cenario_nome, X, y) in cenarios:
    print(f"\n{cenario_nome}:")
    
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=42
    )
    
    scaler = StandardScaler()
    X_train_scaled = scaler.fit_transform(X_train)
    
    for model_name, model in models.items():
        model.fit(X_train_scaled, y_train)
        
        if model_name == 'LDA':
            # LDA - usando atributos corretos disponíveis
            print(f"  {model_name}:")
            print(f"    Forma do scaling: {model.scalings_.shape}")
            print(f"    Número de coeficientes: {len(model.coef_.flatten())}")
            print(f"    Número de classes: {len(model.classes_)}")
            print(f"    Médias por classe: {[f'Classe {i}: {mean}' for i, mean in enumerate(model.means_)]}")
        else:
            # QDA - usando atributos corretos disponíveis
            print(f"  {model_name}:")
            print(f"    Número de classes: {len(model.classes_)}")
            print(f"    Médias por classe: {[f'Classe {i}: {mean}' for i, mean in enumerate(model.means_)]}")
            # Para QDA, as covariâncias são armazenadas de forma diferente
            if hasattr(model, 'covariance_'):
                for i, covariance in enumerate(model.covariance_):
                    print(f"    Classe {i}: forma da matriz {covariance.shape}")
            else:
                print("    Info: Matrizes de covariância disponíveis internamente para cálculo")

'''
Exemplo com dados reais: Iris dataset - VERSÃO CORRIGIDA
'''
from sklearn.datasets import load_iris

print("\n=== EXEMPLO COM DATASET IRIS ===")
iris = load_iris()
X_iris, y_iris = iris.data, iris.target

# Usando apenas duas features para visualização
X_iris_2d = X_iris[:, :2]

X_train_iris, X_test_iris, y_train_iris, y_test_iris = train_test_split(
    X_iris_2d, y_iris, test_size=0.3, random_state=42
)

scaler_iris = StandardScaler()
X_train_iris_scaled = scaler_iris.fit_transform(X_train_iris)
X_test_iris_scaled = scaler_iris.transform(X_test_iris)

for model_name, model in models.items():
    model.fit(X_train_iris_scaled, y_train_iris)
    y_pred_iris = model.predict(X_test_iris_scaled)
    accuracy_iris = accuracy_score(y_test_iris, y_pred_iris)
    
    print(f"{model_name} no dataset Iris: Acurácia = {accuracy_iris:.3f}")
    
    # Informações adicionais específicas de cada modelo - CORRIGIDO
    if model_name == 'LDA':
        print(f"  Número de componentes: {model.n_components}")
        if hasattr(model, 'explained_variance_ratio_'):
            print(f"  Variância explicada: {model.explained_variance_ratio_}")
    else:
        print(f"  Número de classes: {len(model.classes_)}")
        print(f"  Prior probabilities: {model.priors_}")

'''
Demonstração adicional: acesso seguro aos atributos
'''
print("\n=== ATRIBUTOS DISPONÍVEIS POR MODELO ===")

for model_name, model in models.items():
    print(f"\n{model_name} - Atributos disponíveis:")
    atributos = [attr for attr in dir(model) if not attr.startswith('_')]
    # Mostrando apenas os principais atributos
    principais = [attr for attr in atributos if not attr.startswith('_') and 
                 any(keyword in attr for keyword in ['coef', 'mean', 'class', 'score', 'predict'])]
    for attr in principais[:10]:  # Mostrando apenas os 10 primeiros
        print(f"  - {attr}")

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

import numpy as np

import matplotlib.pyplot as plt

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis, QuadraticDiscriminantAnalysis

from sklearn.datasets import make_classification, make_blobs

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score

from sklearn.preprocessing import StandardScaler

'''

Exemplo comparativo entre LDA e QDA em diferentes cenários

de dados para ilustrar suas características distintas

'''

# Cenário 1: Dados com matrizes de covariância similares

print("=== CENÁRIO 1: Matrizes de Covariância Similares ===")

X1, y1 = make_classification(

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

n_clusters_per_class=1, class_sep=2.0, random_state=42

)

# Cenário 2: Dados com matrizes de covariância diferentes

print("=== CENÁRIO 2: Matrizes de Covariância Diferentes ===")

X2, y2 = make_blobs(

n_samples=300, centers=2, cluster_std=[1.0, 2.5],

random_state=42, n_features=2

)

# Transformando para criar covariâncias diferentes

transformation = [[0.6, -0.6], [-0.4, 0.8]]

X2 = np.dot(X2, transformation)

cenarios = [

('Covariância Similar', X1, y1),

('Covariância Diferente', X2, y2)

]

'''

Configurando os modelos e avaliando em cada cenário

'''

models = {

'LDA': LinearDiscriminantAnalysis(),

'QDA': QuadraticDiscriminantAnalysis()

}

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

for cenario_idx, (cenario_nome, X, y) in enumerate(cenarios, 1):

# Dividindo os dados

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.3, random_state=42

)

# Padronizando os dados

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# Criando mesh para plotar fronteiras de decisão

h = 0.02

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

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

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

np.arange(y_min, y_max, h))

for model_idx, (model_name, model) in enumerate(models.items(), 1):

plt.subplot(2, 2, (cenario_idx - 1) * 2 + model_idx)

# Treinando o modelo

model.fit(X_train_scaled, y_train)

# Fazendo previsões

y_pred = model.predict(X_test_scaled)

accuracy = accuracy_score(y_test, y_pred)

# Plotando fronteira de decisão

Z = model.predict(np.c_[xx.ravel(), yy.ravel()])

Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.Paired)

# Plotando dados de treino - CORREÇÃO: removendo parâmetro cmap do scatter

colors = ['red', 'blue', 'green']

for class_idx, class_label in enumerate(np.unique(y_train)):

class_mask = y_train == class_label

plt.scatter(X_train_scaled[class_mask, 0], X_train_scaled[class_mask, 1],

alpha=0.8, label=f'Classe {class_label}',

color=colors[class_idx % len(colors)])

plt.title(f'{cenario_nome}\n{model_name} - Acurácia: {accuracy:.3f}')

plt.xlabel('Feature 1 (padronizada)')

plt.ylabel('Feature 2 (padronizada)')

plt.legend()

plt.tight_layout()

plt.show()

'''

Análise detalhada dos parâmetros dos modelos - VERSÃO CORRIGIDA

'''

print("\n=== ANÁLISE DOS PARÂMETROS ===")

for (cenario_nome, X, y) in cenarios:

print(f"\n{cenario_nome}:")

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.3, random_state=42

)

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

for model_name, model in models.items():

model.fit(X_train_scaled, y_train)

if model_name == 'LDA':

# LDA - usando atributos corretos disponíveis

print(f" {model_name}:")

print(f" Forma do scaling: {model.scalings_.shape}")

print(f" Número de coeficientes: {len(model.coef_.flatten())}")

print(f" Número de classes: {len(model.classes_)}")

print(f" Médias por classe: {[f'Classe {i}: {mean}' for i, mean in enumerate(model.means_)]}")

else:

# QDA - usando atributos corretos disponíveis

print(f" {model_name}:")

print(f" Número de classes: {len(model.classes_)}")

print(f" Médias por classe: {[f'Classe {i}: {mean}' for i, mean in enumerate(model.means_)]}")

# Para QDA, as covariâncias são armazenadas de forma diferente

if hasattr(model, 'covariance_'):

for i, covariance in enumerate(model.covariance_):

print(f" Classe {i}: forma da matriz {covariance.shape}")

else:

print(" Info: Matrizes de covariância disponíveis internamente para cálculo")

'''

Exemplo com dados reais: Iris dataset - VERSÃO CORRIGIDA

'''

from sklearn.datasets import load_iris

print("\n=== EXEMPLO COM DATASET IRIS ===")

iris = load_iris()

X_iris, y_iris = iris.data, iris.target

# Usando apenas duas features para visualização

X_iris_2d = X_iris[:, :2]

X_train_iris, X_test_iris, y_train_iris, y_test_iris = train_test_split(

X_iris_2d, y_iris, test_size=0.3, random_state=42

)

scaler_iris = StandardScaler()

X_train_iris_scaled = scaler_iris.fit_transform(X_train_iris)

X_test_iris_scaled = scaler_iris.transform(X_test_iris)

for model_name, model in models.items():

model.fit(X_train_iris_scaled, y_train_iris)

y_pred_iris = model.predict(X_test_iris_scaled)

accuracy_iris = accuracy_score(y_test_iris, y_pred_iris)

print(f"{model_name} no dataset Iris: Acurácia = {accuracy_iris:.3f}")

# Informações adicionais específicas de cada modelo - CORRIGIDO

if model_name == 'LDA':

print(f" Número de componentes: {model.n_components}")

if hasattr(model, 'explained_variance_ratio_'):

print(f" Variância explicada: {model.explained_variance_ratio_}")

else:

print(f" Número de classes: {len(model.classes_)}")

print(f" Prior probabilities: {model.priors_}")

'''

Demonstração adicional: acesso seguro aos atributos

'''

print("\n=== ATRIBUTOS DISPONÍVEIS POR MODELO ===")

for model_name, model in models.items():

print(f"\n{model_name} - Atributos disponíveis:")

atributos = [attr for attr in dir(model) if not attr.startswith('_')]

# Mostrando apenas os principais atributos

principais = [attr for attr in atributos if not attr.startswith('_') and

any(keyword in attr for keyword in ['coef', 'mean', 'class', 'score', 'predict'])]

for attr in principais[:10]: # Mostrando apenas os 10 primeiros

print(f" - {attr}")

Interpretação dos Resultados

Analisando o exemplo, podemos observar que:

No cenário com matrizes de covariância similares, LDA e QDA performam similarmente
No cenário com matrizes de covariância diferentes, QDA geralmente supera LDA
As fronteiras de decisão do LDA são sempre lineares, enquanto as do QDA são quadráticas
O LDA estima menos parâmetros, tornando-o mais eficiente com dados limitados

Considerações Práticas

Ao aplicar LDA ou QDA em problemas reais, é importante considerar:

Verificar os pressupostos de normalidade quando possível
Considerar o tamanho do dataset para escolha entre LDA e QDA
Utilizar validação cruzada para avaliação robusta do desempenho
Explorar a redução de dimensionalidade oferecida pelo LDA

Vantagens e Limitações

Embora poderosos, ambos os métodos têm suas particularidades:

LDA: Mais robusto mas menos flexível
QDA: Mais flexível mas requer mais dados
Ambos: Sensíveis a violações dos pressupostos de normalidade
Excelente desempenho quando os pressupostos são atendidos

Portanto, a escolha entre LDA e QDA deve considerar as características específicas dos dados e os objetivos do projeto. Inclusive, em muitos casos práticos, testar ambas as abordagens com validação adequada pode revelar qual método é mais apropriado para o problema em questão.