Arquivo de Python - Página 46 de 94

Modelos Lineares Generalizados: Laço (Lasso)

19/12/202518/10/2025 Por antonino

Anteriormente discutimos a Regressão Linear tradicional e Ridge. Analogamente, o Lasso (Least Absolute Shrinkage and Selection Operator) é outra técnica de regularização que adiciona uma penalidade L1 à função objetivo, promovendo esparsidade nos coeficientes do modelo.

Conceito Fundamental do Lasso

Primordialmente, o Lasso realiza não apenas a regularização dos coeficientes, mas também seleção de features. Decerto, ao adicionar uma penalidade baseada no valor absoluto dos coeficientes, ele tende a zerar os coeficientes de features menos importantes.

Conforme a documentação do scikit-learn, o Lasso é particularmente útil quando acreditamos que apenas um subconjunto das features é realmente relevante para a previsão. Similarmente ao Ridge, ele ajuda a prevenir overfitting, mas com características distintas.

Formulação Matemática

O objetivo do Lasso é minimizar a seguinte função:

\(\min_{w} \frac{1}{2n}||Xw – y||_2^2 + \alpha||w||_1\)

Onde:

X é a matriz de features
y é o vetor target
w são os coeficientes do modelo
α é o parâmetro de regularização
||w||₁ é a norma L1 dos coeficientes

Características Principais do Lasso

Inegavelmente, o Lasso possui propriedades únicas que o distinguem de outras técnicas de regularização:

Seleção de features: Zera coeficientes de features irrelevantes
Esparsidade: Produz modelos com poucas features não-zero
Interpretabilidade: Modelos mais simples e interpretáveis
Regularização L1: Penalidade baseada no valor absoluto

Comparação: Lasso vs Ridge

Embora ambos sejam técnicas de regularização, existem diferenças fundamentais:

Lasso (L1): Promove esparsidade, zera coeficientes
Ridge (L2): Reduz coeficientes, mas não zera
ElasticNet: Combina L1 e L2

Parâmetros do Lasso

Os principais parâmetros para ajuste no Lasso são:

alpha: Parâmetro de regularização (α)
max_iter: Número máximo de iterações
tol: Tolerância para critério de parada
selection: Estratégia de seleção de coeficientes

Exemplo Prático: Aplicação do Lasso

Ademais, vejamos um exemplo completo demonstrando o uso do Lasso:

'''
Aplicação do Lasso para Regressão com Seleção de Features
Este exemplo demonstra como o Lasso pode ser usado
para selecionar features relevantes e evitar overfitting
'''

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.linear_model import Lasso, Ridge, LinearRegression
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score

# Gerar dataset com algumas features irrelevantes
X, y, true_coef = make_regression(n_samples=1000, n_features=20, 
                                 n_informative=8, noise=10, 
                                 coef=True, random_state=42)

print("Informações do Dataset:")
print(f"Número de amostras: {X.shape[0]}")
print(f"Número de features: {X.shape[1]}")
print(f"Features informativas: 8")
print(f"Coeficientes verdadeiros não-zero: {np.sum(true_coef != 0)}")

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

# Normalizar os dados (importante para regularização)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

print(f"\nDimensões: Treino {X_train.shape}, Teste {X_test.shape}")

'''
Comparação entre Regressão Linear, Ridge e Lasso
Cada método tem características diferentes de regularização
'''

models = {
    'Linear': LinearRegression(),
    'Ridge': Ridge(alpha=1.0),
    'Lasso': Lasso(alpha=1.0)
}

results = {}

print("\n--- Comparação de Modelos ---")
for name, model in models.items():
    # Treinar modelo
    model.fit(X_train_scaled, y_train)
    
    # Fazer previsões
    y_pred = model.predict(X_test_scaled)
    
    # Calcular métricas
    mse = mean_squared_error(y_test, y_pred)
    r2 = r2_score(y_test, y_pred)
    
    # Armazenar resultados
    if hasattr(model, 'coef_'):
        n_nonzero = np.sum(model.coef_ != 0)
        results[name] = {
            'model': model,
            'mse': mse,
            'r2': r2,
            'n_nonzero': n_nonzero,
            'coef': model.coef_
        }
    else:
        results[name] = {
            'model': model,
            'mse': mse,
            'r2': r2,
            'n_nonzero': X.shape[1],
            'coef': None
        }
    
    print(f"{name:8} - MSE: {mse:.2f}, R²: {r2:.3f}, Features não-zero: {results[name]['n_nonzero']}")

# Otimização do parâmetro alpha para Lasso
print("\n--- Otimização do Parâmetro Alpha para Lasso ---")

param_grid = {
    'alpha': [0.001, 0.01, 0.1, 1, 10, 100, 1000]
}

grid_search = GridSearchCV(Lasso(max_iter=10000), param_grid, cv=5, 
                          scoring='neg_mean_squared_error', n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

print(f"Melhor alpha: {grid_search.best_params_['alpha']}")
print(f"Melhor MSE na validação: {-grid_search.best_score_:.2f}")

# Modelo Lasso otimizado
best_lasso = grid_search.best_estimator_
y_pred_best = best_lasso.predict(X_test_scaled)
final_mse = mean_squared_error(y_test, y_pred_best)
final_r2 = r2_score(y_test, y_pred_best)
n_nonzero_best = np.sum(best_lasso.coef_ != 0)

print(f"\nLasso Otimizado - MSE: {final_mse:.2f}, R²: {final_r2:.3f}")
print(f"Features selecionadas: {n_nonzero_best} de {X.shape[1]}")

# Análise dos coeficientes
print("\n--- Análise dos Coeficientes ---")
print("Comparação entre coeficientes verdadeiros e estimados:")

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

# Plot 1: Comparação de coeficientes
plt.subplot(2, 2, 1)
features = range(len(true_coef))
plt.plot(features, true_coef, 'o-', label='Verdadeiro', linewidth=2, markersize=8)
plt.plot(features, results['Linear']['coef'], 's-', label='Linear', alpha=0.7)
plt.plot(features, results['Ridge']['coef'], '^-', label='Ridge', alpha=0.7)
plt.plot(features, best_lasso.coef_, 'd-', label='Lasso (Otimizado)', alpha=0.7)
plt.xlabel('Feature Index')
plt.ylabel('Valor do Coeficiente')
plt.title('Comparação dos Coeficientes')
plt.legend()
plt.grid(True, alpha=0.3)

# Plot 2: Features selecionadas pelo Lasso
plt.subplot(2, 2, 2)
lasso_coef_nonzero = best_lasso.coef_ != 0
true_coef_nonzero = true_coef != 0

# Calcular acurácia na seleção de features
correct_selection = np.sum(lasso_coef_nonzero == true_coef_nonzero)
selection_accuracy = correct_selection / len(true_coef)

plt.bar(['Selecionadas', 'Não Selecionadas'], 
        [np.sum(lasso_coef_nonzero), np.sum(~lasso_coef_nonzero)],
        color=['lightcoral', 'lightblue'])
plt.title(f'Seleção de Features pelo Lasso\nAcurácia: {selection_accuracy:.1%}')
plt.ylabel('Número de Features')

# Plot 3: Performance vs Alpha
plt.subplot(2, 2, 3)
alphas = param_grid['alpha']
cv_scores = -grid_search.cv_results_['mean_test_score']

plt.semilogx(alphas, cv_scores, 'o-', linewidth=2)
plt.xlabel('Alpha')
plt.ylabel('MSE')
plt.title('Performance vs Parâmetro Alpha')
plt.grid(True, alpha=0.3)

# Plot 4: Comparação de MSE
plt.subplot(2, 2, 4)
model_names = list(results.keys()) + ['Lasso Otimizado']
mses = [results[name]['mse'] for name in results.keys()] + [final_mse]

plt.bar(model_names, mses, color=['skyblue', 'lightgreen', 'gold', 'lightcoral'])
plt.ylabel('MSE')
plt.title('Comparação de Erro Quadrático Médio')
plt.xticks(rotation=45)

plt.tight_layout()
plt.show()

# Análise detalhada da seleção de features
print(f"\n--- Análise Detalhada da Seleção de Features ---")
print(f"Coeficientes verdadeiros não-zero: {np.sum(true_coef != 0)}")
print(f"Coeficientes Lasso não-zero: {np.sum(best_lasso.coef_ != 0)}")
print(f"Features corretamente selecionadas: {np.sum((best_lasso.coef_ != 0) & (true_coef != 0))}")
print(f"Features corretamente excluídas: {np.sum((best_lasso.coef_ == 0) & (true_coef == 0))}")
print(f"Acurácia total na seleção: {selection_accuracy:.1%}")

# Exemplo de interpretação do modelo
print(f"\n--- Interpretação do Modelo Lasso ---")
print("Features mais importantes (maiores coeficientes em valor absoluto):")

important_features = np.argsort(np.abs(best_lasso.coef_))[::-1][:5]
for i, feat_idx in enumerate(important_features):
    if best_lasso.coef_[feat_idx] != 0:
        print(f"Feature {feat_idx:2d}: coeficiente = {best_lasso.coef_[feat_idx]:.3f}")

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

'''

Aplicação do Lasso para Regressão com Seleção de Features

Este exemplo demonstra como o Lasso pode ser usado

para selecionar features relevantes e evitar overfitting

'''

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_regression

from sklearn.linear_model import Lasso, Ridge, LinearRegression

from sklearn.model_selection import train_test_split, GridSearchCV

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import mean_squared_error, r2_score

# Gerar dataset com algumas features irrelevantes

X, y, true_coef = make_regression(n_samples=1000, n_features=20,

n_informative=8, noise=10,

coef=True, random_state=42)

print("Informações do Dataset:")

print(f"Número de amostras: {X.shape[0]}")

print(f"Número de features: {X.shape[1]}")

print(f"Features informativas: 8")

print(f"Coeficientes verdadeiros não-zero: {np.sum(true_coef != 0)}")

# Dividir em treino e teste

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

random_state=42)

# Normalizar os dados (importante para regularização)

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

print(f"\nDimensões: Treino {X_train.shape}, Teste {X_test.shape}")

'''

Comparação entre Regressão Linear, Ridge e Lasso

Cada método tem características diferentes de regularização

'''

models = {

'Linear': LinearRegression(),

'Ridge': Ridge(alpha=1.0),

'Lasso': Lasso(alpha=1.0)

}

results = {}

print("\n--- Comparação de Modelos ---")

for name, model in models.items():

# Treinar modelo

model.fit(X_train_scaled, y_train)

# Fazer previsões

y_pred = model.predict(X_test_scaled)

# Calcular métricas

mse = mean_squared_error(y_test, y_pred)

r2 = r2_score(y_test, y_pred)

# Armazenar resultados

if hasattr(model, 'coef_'):

n_nonzero = np.sum(model.coef_ != 0)

results[name] = {

'model': model,

'mse': mse,

'r2': r2,

'n_nonzero': n_nonzero,

'coef': model.coef_

}

else:

results[name] = {

'model': model,

'mse': mse,

'r2': r2,

'n_nonzero': X.shape[1],

'coef': None

}

print(f"{name:8} - MSE: {mse:.2f}, R²: {r2:.3f}, Features não-zero: {results[name]['n_nonzero']}")

# Otimização do parâmetro alpha para Lasso

print("\n--- Otimização do Parâmetro Alpha para Lasso ---")

param_grid = {

'alpha': [0.001, 0.01, 0.1, 1, 10, 100, 1000]

}

grid_search = GridSearchCV(Lasso(max_iter=10000), param_grid, cv=5,

scoring='neg_mean_squared_error', n_jobs=-1)

grid_search.fit(X_train_scaled, y_train)

print(f"Melhor alpha: {grid_search.best_params_['alpha']}")

print(f"Melhor MSE na validação: {-grid_search.best_score_:.2f}")

# Modelo Lasso otimizado

best_lasso = grid_search.best_estimator_

y_pred_best = best_lasso.predict(X_test_scaled)

final_mse = mean_squared_error(y_test, y_pred_best)

final_r2 = r2_score(y_test, y_pred_best)

n_nonzero_best = np.sum(best_lasso.coef_ != 0)

print(f"\nLasso Otimizado - MSE: {final_mse:.2f}, R²: {final_r2:.3f}")

print(f"Features selecionadas: {n_nonzero_best} de {X.shape[1]}")

# Análise dos coeficientes

print("\n--- Análise dos Coeficientes ---")

print("Comparação entre coeficientes verdadeiros e estimados:")

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

# Plot 1: Comparação de coeficientes

plt.subplot(2, 2, 1)

features = range(len(true_coef))

plt.plot(features, true_coef, 'o-', label='Verdadeiro', linewidth=2, markersize=8)

plt.plot(features, results['Linear']['coef'], 's-', label='Linear', alpha=0.7)

plt.plot(features, results['Ridge']['coef'], '^-', label='Ridge', alpha=0.7)

plt.plot(features, best_lasso.coef_, 'd-', label='Lasso (Otimizado)', alpha=0.7)

plt.xlabel('Feature Index')

plt.ylabel('Valor do Coeficiente')

plt.title('Comparação dos Coeficientes')

plt.legend()

plt.grid(True, alpha=0.3)

# Plot 2: Features selecionadas pelo Lasso

plt.subplot(2, 2, 2)

lasso_coef_nonzero = best_lasso.coef_ != 0

true_coef_nonzero = true_coef != 0

# Calcular acurácia na seleção de features

correct_selection = np.sum(lasso_coef_nonzero == true_coef_nonzero)

selection_accuracy = correct_selection / len(true_coef)

plt.bar(['Selecionadas', 'Não Selecionadas'],

[np.sum(lasso_coef_nonzero), np.sum(~lasso_coef_nonzero)],

color=['lightcoral', 'lightblue'])

plt.title(f'Seleção de Features pelo Lasso\nAcurácia: {selection_accuracy:.1%}')

plt.ylabel('Número de Features')

# Plot 3: Performance vs Alpha

plt.subplot(2, 2, 3)

alphas = param_grid['alpha']

cv_scores = -grid_search.cv_results_['mean_test_score']

plt.semilogx(alphas, cv_scores, 'o-', linewidth=2)

plt.xlabel('Alpha')

plt.ylabel('MSE')

plt.title('Performance vs Parâmetro Alpha')

plt.grid(True, alpha=0.3)

# Plot 4: Comparação de MSE

plt.subplot(2, 2, 4)

model_names = list(results.keys()) + ['Lasso Otimizado']

mses = [results[name]['mse'] for name in results.keys()] + [final_mse]

plt.bar(model_names, mses, color=['skyblue', 'lightgreen', 'gold', 'lightcoral'])

plt.ylabel('MSE')

plt.title('Comparação de Erro Quadrático Médio')

plt.xticks(rotation=45)

plt.tight_layout()

plt.show()

# Análise detalhada da seleção de features

print(f"\n--- Análise Detalhada da Seleção de Features ---")

print(f"Coeficientes verdadeiros não-zero: {np.sum(true_coef != 0)}")

print(f"Coeficientes Lasso não-zero: {np.sum(best_lasso.coef_ != 0)}")

print(f"Features corretamente selecionadas: {np.sum((best_lasso.coef_ != 0) & (true_coef != 0))}")

print(f"Features corretamente excluídas: {np.sum((best_lasso.coef_ == 0) & (true_coef == 0))}")

print(f"Acurácia total na seleção: {selection_accuracy:.1%}")

# Exemplo de interpretação do modelo

print(f"\n--- Interpretação do Modelo Lasso ---")

print("Features mais importantes (maiores coeficientes em valor absoluto):")

important_features = np.argsort(np.abs(best_lasso.coef_))[::-1][:5]

for i, feat_idx in enumerate(important_features):

if best_lasso.coef_[feat_idx] != 0:

print(f"Feature {feat_idx:2d}: coeficiente = {best_lasso.coef_[feat_idx]:.3f}")

Vantagens e Limitações do Lasso

Embora o Lasso seja poderoso, é importante compreender suas características:

Vantagens

Seleção automática de features
Modelos mais interpretáveis
Bom para high-dimensional data
Prevenção de overfitting

Limitações

Pode selecionar apenas uma feature de grupo correlacionado
Sensível à escala dos dados
Pode não performar bem quando todas features são relevantes
Requer ajuste cuidadoso do parâmetro alpha

Casos de Uso Recomendados

O Lasso é particularmente útil em:

Problemas com muitas features e amostras limitadas
Quando se deseja interpretabilidade do modelo
Para seleção de features automática
Em datasets onde muitas features são irrelevantes

Enfim, o Lasso representa uma ferramenta valiosa no arsenal de machine learning, combinando regularização com seleção de features de maneira eficiente e interpretável.

Referência: https://scikit-learn.org/0.21/modules/linear_model.html#lasso

Máquinas de Vetores de Suporte: Classificação

19/12/202518/10/2025 Por antonino

Anteriormente introduzimos os conceitos fundamentais dos Support Vector Machines. Analogamente, agora exploraremos sua aplicação específica para problemas de classificação, que é uma das utilizações mais comuns e bem-sucedidas desses algoritmos.

Fundamentos da Classificação com SVM

Primordialmente, o SVC (Support Vector Classification) é a implementação do scikit-learn para problemas de classificação. Decerto, seu objetivo é encontrar o hiperplano ótimo que separa as classes com a maior margem possível.

Conforme a documentação, o SVC suporta tanto classificação binária quanto multiclasse através da abordagem “one-vs-one”. Similarmente, para problemas linearmente separáveis, o algoritmo busca maximizar a margem entre as classes.

Formulação Matemática

Para dados linearmente separáveis, o problema de otimização é formulado como:

\(\min_{w,b} \frac{1}{2}||w||^2\)

Sujeito a:

\(y_i(w \cdot x_i + b) \geq 1, \quad \forall i\)

Para dados não linearmente separáveis, introduzimos variáveis de folga:

\(\min_{w,b,\xi} \frac{1}{2}||w||^2 + C\sum_{i=1}^n \xi_i\)

Sujeito a:

\(y_i(w \cdot x_i + b) \geq 1 – \xi_i, \quad \xi_i \geq 0\)

Implementações Disponíveis

Atualmente, o scikit-learn oferece três implementações principais para classificação:

SVC: Implementação versátil baseada no libsvm
NuSVC: Similar ao SVC mas com parâmetro ν controlando o número de vetores de suporte
LinearSVC: Implementação otimizada para classificação linear

Diferenças entre SVC e LinearSVC

Inegavelmente, compreender as diferenças entre essas implementações é crucial:

SVC: Suporta kernels não-lineares, usa one-vs-one para multiclasse
LinearSVC: Mais escalável, usa one-vs-rest para multiclasse
NuSVC: Controla diretamente o número de vetores de suporte

Parâmetros Principais

Conquanto existam muitos parâmetros, alguns são particularmente importantes:

C: Parâmetro de regularização que controla o trade-off entre margem e erro
kernel: Tipo de função do kernel (linear, rbf, poly, sigmoid)
gamma: Coeficiente para kernels rbf, poly e sigmoid
degree: Grau do kernel polinomial

Exemplo Prático: Classificação com Diferentes Kernels

Ademais, vejamos um exemplo completo de classificação utilizando diferentes abordagens:

'''
Classificação com Support Vector Machines
Este exemplo demonstra o uso do SVC para problemas
de classificação binária e multiclasse
'''

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.svm import SVC, LinearSVC
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

# Carregar dataset Iris para classificação multiclasse
iris = datasets.load_iris()
X = iris.data
y = iris.target
target_names = iris.target_names

print("Dataset Iris - Informações:")
print(f"Número de amostras: {X.shape[0]}")
print(f"Número de features: {X.shape[1]}")
print(f"Classes: {target_names}")
print(f"Distribuição das classes: {np.bincount(y)}")

# Dividir em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, 
                                                    random_state=42,
                                                    stratify=y)

# Normalizar os dados
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

print(f"\nDimensões: Treino {X_train.shape}, Teste {X_test.shape}")

'''
Comparação de diferentes kernels para classificação
Cada kernel tem características distintas que podem
ser mais adequadas para diferentes tipos de dados
'''

kernels = ['linear', 'rbf', 'poly']
results = {}

for kernel in kernels:
    print(f"\n--- Treinando SVC com kernel {kernel} ---")
    
    if kernel == 'poly':
        svc = SVC(kernel=kernel, degree=3, random_state=42)
    else:
        svc = SVC(kernel=kernel, random_state=42)
    
    # Treinar modelo
    svc.fit(X_train_scaled, y_train)
    
    # Fazer previsões
    y_pred = svc.predict(X_test_scaled)
    
    # Calcular acurácia
    accuracy = accuracy_score(y_test, y_pred)
    
    # Armazenar resultados
    results[kernel] = {
        'model': svc,
        'accuracy': accuracy,
        'n_support_vectors': len(svc.support_vectors_)
    }
    
    print(f"Acurácia: {accuracy:.3f}")
    print(f"Vetores de suporte: {len(svc.support_vectors_)}")
    print(f"Distribuição por classe: {np.bincount(svc.n_support_)}")

# Comparação com LinearSVC
print("\n--- Comparação com LinearSVC ---")
linear_svc = LinearSVC(random_state=42, max_iter=10000)
linear_svc.fit(X_train_scaled, y_train)
y_pred_linear = linear_svc.predict(X_test_scaled)
accuracy_linear = accuracy_score(y_test, y_pred_linear)

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

# Otimização de hiperparâmetros com GridSearchCV
print("\n--- Otimização de Hiperparâmetros com GridSearchCV ---")

param_grid = {
    'C': [0.1, 1, 10, 100],
    'gamma': ['scale', 'auto', 0.1, 0.01],
    'kernel': ['rbf', 'linear']
}

grid_search = GridSearchCV(SVC(random_state=42), param_grid, cv=5, 
                          scoring='accuracy', n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

print(f"Melhores parâmetros: {grid_search.best_params_}")
print(f"Melhor score na validação: {grid_search.best_score_:.3f}")

# Modelo final com melhores parâmetros
best_svc = grid_search.best_estimator_
y_pred_best = best_svc.predict(X_test_scaled)
final_accuracy = accuracy_score(y_test, y_pred_best)

print(f"Acurácia final no teste: {final_accuracy:.3f}")

# Relatório de classificação detalhado
print("\n--- Relatório de Classificação Detalhado ---")
print(classification_report(y_test, y_pred_best, target_names=target_names))

# Matriz de confusão
cm = confusion_matrix(y_test, y_pred_best)
print("\nMatriz de Confusão:")
print(cm)

# Visualização dos resultados (para duas primeiras features)
plt.figure(figsize=(15, 5))

# Plot dos dados originais
plt.subplot(1, 3, 1)
for i, target_name in enumerate(target_names):
    plt.scatter(X[y == i, 0], X[y == i, 1], label=target_name, alpha=0.7)
plt.xlabel('Comprimento da Sépala')
plt.ylabel('Largura da Sépala')
plt.title('Dados Originais - Iris Dataset')
plt.legend()

# Plot das previsões
plt.subplot(1, 3, 2)
for i, target_name in enumerate(target_names):
    mask = (y_pred_best == i)
    plt.scatter(X_test[mask, 0], X_test[mask, 1], label=target_name, alpha=0.7)
plt.xlabel('Comprimento da Sépala')
plt.ylabel('Largura da Sépala')
plt.title('Previsões do Modelo')
plt.legend()

# Plot de comparação de acurácias
plt.subplot(1, 3, 3)
methods = list(results.keys()) + ['LinearSVC', 'Otimizado']
accuracies = [results[k]['accuracy'] for k in kernels] + [accuracy_linear, final_accuracy]

plt.bar(methods, accuracies, color=['skyblue', 'lightcoral', 'lightgreen', 'gold', 'violet'])
plt.xticks(rotation=45)
plt.ylabel('Acurácia')
plt.title('Comparação de Acurácias por Método')
plt.ylim(0, 1)

plt.tight_layout()
plt.show()

# Análise final
print(f"\n--- Resumo Final ---")
print(f"Melhor método: {grid_search.best_params_['kernel']} kernel")
print(f"Acurácia final: {final_accuracy:.3f}")
print(f"Total de vetores de suporte: {len(best_svc.support_vectors_)}")
print(f"Percentual de vetores de suporte: {len(best_svc.support_vectors_)/len(X_train)*100:.1f}%")

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

'''

Classificação com Support Vector Machines

Este exemplo demonstra o uso do SVC para problemas

de classificação binária e multiclasse

'''

import numpy as np

import matplotlib.pyplot as plt

from sklearn import datasets

from sklearn.svm import SVC, LinearSVC

from sklearn.model_selection import train_test_split, GridSearchCV

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

# Carregar dataset Iris para classificação multiclasse

iris = datasets.load_iris()

X = iris.data

y = iris.target

target_names = iris.target_names

print("Dataset Iris - Informações:")

print(f"Número de amostras: {X.shape[0]}")

print(f"Número de features: {X.shape[1]}")

print(f"Classes: {target_names}")

print(f"Distribuição das classes: {np.bincount(y)}")

# Dividir em treino e teste

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

random_state=42,

stratify=y)

# Normalizar os dados

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

print(f"\nDimensões: Treino {X_train.shape}, Teste {X_test.shape}")

'''

Comparação de diferentes kernels para classificação

Cada kernel tem características distintas que podem

ser mais adequadas para diferentes tipos de dados

'''

kernels = ['linear', 'rbf', 'poly']

results = {}

for kernel in kernels:

print(f"\n--- Treinando SVC com kernel {kernel} ---")

if kernel == 'poly':

svc = SVC(kernel=kernel, degree=3, random_state=42)

else:

svc = SVC(kernel=kernel, random_state=42)

# Treinar modelo

svc.fit(X_train_scaled, y_train)

# Fazer previsões

y_pred = svc.predict(X_test_scaled)

# Calcular acurácia

accuracy = accuracy_score(y_test, y_pred)

# Armazenar resultados

results[kernel] = {

'model': svc,

'accuracy': accuracy,

'n_support_vectors': len(svc.support_vectors_)

}

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

print(f"Vetores de suporte: {len(svc.support_vectors_)}")

print(f"Distribuição por classe: {np.bincount(svc.n_support_)}")

# Comparação com LinearSVC

print("\n--- Comparação com LinearSVC ---")

linear_svc = LinearSVC(random_state=42, max_iter=10000)

linear_svc.fit(X_train_scaled, y_train)

y_pred_linear = linear_svc.predict(X_test_scaled)

accuracy_linear = accuracy_score(y_test, y_pred_linear)

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

# Otimização de hiperparâmetros com GridSearchCV

print("\n--- Otimização de Hiperparâmetros com GridSearchCV ---")

param_grid = {

'C': [0.1, 1, 10, 100],

'gamma': ['scale', 'auto', 0.1, 0.01],

'kernel': ['rbf', 'linear']

}

grid_search = GridSearchCV(SVC(random_state=42), param_grid, cv=5,

scoring='accuracy', n_jobs=-1)

grid_search.fit(X_train_scaled, y_train)

print(f"Melhores parâmetros: {grid_search.best_params_}")

print(f"Melhor score na validação: {grid_search.best_score_:.3f}")

# Modelo final com melhores parâmetros

best_svc = grid_search.best_estimator_

y_pred_best = best_svc.predict(X_test_scaled)

final_accuracy = accuracy_score(y_test, y_pred_best)

print(f"Acurácia final no teste: {final_accuracy:.3f}")

# Relatório de classificação detalhado

print("\n--- Relatório de Classificação Detalhado ---")

print(classification_report(y_test, y_pred_best, target_names=target_names))

# Matriz de confusão

cm = confusion_matrix(y_test, y_pred_best)

print("\nMatriz de Confusão:")

print(cm)

# Visualização dos resultados (para duas primeiras features)

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

# Plot dos dados originais

plt.subplot(1, 3, 1)

for i, target_name in enumerate(target_names):

plt.scatter(X[y == i, 0], X[y == i, 1], label=target_name, alpha=0.7)

plt.xlabel('Comprimento da Sépala')

plt.ylabel('Largura da Sépala')

plt.title('Dados Originais - Iris Dataset')

plt.legend()

# Plot das previsões

plt.subplot(1, 3, 2)

for i, target_name in enumerate(target_names):

mask = (y_pred_best == i)

plt.scatter(X_test[mask, 0], X_test[mask, 1], label=target_name, alpha=0.7)

plt.xlabel('Comprimento da Sépala')

plt.ylabel('Largura da Sépala')

plt.title('Previsões do Modelo')

plt.legend()

# Plot de comparação de acurácias

plt.subplot(1, 3, 3)

methods = list(results.keys()) + ['LinearSVC', 'Otimizado']

accuracies = [results[k]['accuracy'] for k in kernels] + [accuracy_linear, final_accuracy]

plt.bar(methods, accuracies, color=['skyblue', 'lightcoral', 'lightgreen', 'gold', 'violet'])

plt.xticks(rotation=45)

plt.ylabel('Acurácia')

plt.title('Comparação de Acurácias por Método')

plt.ylim(0, 1)

plt.tight_layout()

plt.show()

# Análise final

print(f"\n--- Resumo Final ---")

print(f"Melhor método: {grid_search.best_params_['kernel']} kernel")

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

print(f"Total de vetores de suporte: {len(best_svc.support_vectors_)}")

print(f"Percentual de vetores de suporte: {len(best_svc.support_vectors_)/len(X_train)*100:.1f}%")

Casos de Uso e Recomendações

Embora o SVC seja versátil, algumas recomendações práticas são importantes:

Quando Usar SVC

Problemas com limites de decisão complexos
Quando o número de features é maior que o número de amostras
Para problemas que requerem alta generalização
Quando se tem recursos computacionais suficientes

Quando Preferir LinearSVC

Datasets muito grandes
Problemas linearmente separáveis
Quando a velocidade é crucial
Para problemas com muitas features

Considerações sobre Multiclasse

O scikit-learn implementa duas estratégias para classificação multiclasse:

one-vs-one: Treina um classificador para cada par de classes (usado no SVC)
one-vs-rest: Treina um classificador por classe contra todas as outras (usado no LinearSVC)

Enfim, a classificação com Support Vector Machines oferece uma abordagem robusta e flexível para diversos tipos de problemas, desde os mais simples até os mais complexos, sempre buscando a melhor generalização possível.

Referência: https://scikit-learn.org/0.21/modules/svm.html#classification