Arquivo de maquinas-de-vetores-de-suporte

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

Máquinas de Vetores de Suporte: Dicas de Uso Prático

19/12/202518/10/2025 Por antonino

Anteriormente discutimos a complexidade dos SVM. Analogamente, é fundamental compreender as melhores práticas para utilizá-los efetivamente em projetos reais de machine learning.

Pré-processamento de Dados

Primordialmente, os Support Vector Machines são sensíveis à escala dos dados. Decerto, a normalização adequada é crucial para o desempenho do modelo.

StandardScaler: Remove a média e escala para variância unitária
MinMaxScaler: Escala os dados para um range específico, geralmente [0, 1]
RobustScaler: Utiliza mediana e quartis, robusto a outliers

Escolha do Kernel

Conforme a documentação, a seleção do kernel apropriado depende das características do dataset:

Linear: Recomendado para datasets grandes ou quando há muitas features
RBF: Kernel padrão, funciona bem na maioria dos casos
Polynomial: Útil quando há conhecimento prévio sobre a natureza polinomial dos dados
Sigmoid: Similar ao MLP, mas menos utilizado na prática

Ajuste de Hiperparâmetros

Inegavelmente, o ajuste adequado dos hiperparâmetros é essencial para obter bons resultados:

Parâmetro C (Regularização)

O parâmetro C controla o trade-off entre margem e erro de classificação:

Valores pequenos de C: Margem larga, pode underfit
Valores grandes de C: Margem estreita, pode overfit
Valor padrão: C=1.0

Parâmetro γ (Gamma)

Para kernels RBF e polynomial, γ controla a influência de cada exemplo:

Valores pequenos de γ: Influência ampla, decisão suave
Valores grandes de γ: Influência restrita, decisão complexa
Escolha comum: scale ou auto

Seleção de Implementação

Atualmente, o scikit-learn oferece múltiplas implementações:

SVC: Implementação versátil com suporte a vários kernels
LinearSVC: Otimizado para kernels lineares, mais escalável
NuSVC: Controla o número de vetores de suporte via parâmetro ν
SGDClassifier: Ideal para datasets muito grandes com loss=’hinge’

Exemplo Prático: Pipeline Completo

Ademais, vejamos um exemplo completo aplicando as melhores práticas:

'''
Pipeline Completo de SVM com Melhores Práticas
Este exemplo demonstra um fluxo de trabalho completo
com pré-processamento, busca de hiperparâmetros e avaliação
'''

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

# Gerar dataset de exemplo
X, y = make_classification(n_samples=1000, n_features=20, n_redundant=5,
                          n_informative=10, n_clusters_per_class=1,
                          random_state=42)

# 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)

print("Dimensões dos dados:")
print(f"Treino: {X_train.shape}, Teste: {X_test.shape}")

'''
Criar pipeline com pré-processamento e modelo
O pipeline garante que o scaler seja ajustado apenas nos dados de treino
'''
pipeline = Pipeline([
    ('scaler', StandardScaler()),  # Normalização dos dados
    ('svm', SVC(kernel='rbf', random_state=42))  # Modelo SVM com kernel RBF
])

'''
Definir espaço de busca para GridSearch
Busca combinatória dos melhores hiperparâmetros
'''
param_grid = {
    'svm__C': [0.1, 1, 10, 100],  # Valores de regularização
    'svm__gamma': ['scale', 'auto', 0.1, 0.01],  # Valores de gamma
    'svm__kernel': ['rbf', 'linear']  # Tipos de kernel
}

print("\nIniciando busca de hiperparâmetros...")

# Executar GridSearch com validação cruzada
grid_search = GridSearchCV(pipeline, param_grid, cv=5, scoring='accuracy',
                          n_jobs=-1, verbose=1)
grid_search.fit(X_train, y_train)

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

# Fazer previsões com o melhor modelo
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)

# Avaliar o modelo
print("\nRelatório de Classificação:")
print(classification_report(y_test, y_pred))

# Análise dos resultados do GridSearch
results = grid_search.cv_results_
print(f"\nNúmero de combinações testadas: {len(results['params'])}")

# Visualizar performance dos diferentes parâmetros
plt.figure(figsize=(12, 6))

# Extrair scores para kernel RBF
rbf_mask = [i for i, params in enumerate(results['params']) 
           if params['svm__kernel'] == 'rbf']
rbf_scores = results['mean_test_score'][rbf_mask]

plt.subplot(1, 2, 1)
plt.plot(range(len(rbf_scores)), rbf_scores, 'o-')
plt.title('Performance - Kernel RBF')
plt.xlabel('Combinação de Parâmetros')
plt.ylabel('Acurácia')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Análise dos vetores de suporte do melhor modelo
svm_model = best_model.named_steps['svm']
print(f"\nNúmero de vetores de suporte: {len(svm_model.support_vectors_)}")
print(f"Percentual de vetores de suporte: {len(svm_model.support_vectors_)/len(X_train)*100:.1f}%")

'''

Pipeline Completo de SVM com Melhores Práticas

Este exemplo demonstra um fluxo de trabalho completo

com pré-processamento, busca de hiperparâmetros e avaliação

'''

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split, GridSearchCV

from sklearn.preprocessing import StandardScaler

from sklearn.svm import SVC

from sklearn.pipeline import Pipeline

from sklearn.metrics import classification_report, confusion_matrix

# Gerar dataset de exemplo

X, y = make_classification(n_samples=1000, n_features=20, n_redundant=5,

n_informative=10, n_clusters_per_class=1,

random_state=42)

# 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)

print("Dimensões dos dados:")

print(f"Treino: {X_train.shape}, Teste: {X_test.shape}")

'''

Criar pipeline com pré-processamento e modelo

O pipeline garante que o scaler seja ajustado apenas nos dados de treino

'''

pipeline = Pipeline([

('scaler', StandardScaler()), # Normalização dos dados

('svm', SVC(kernel='rbf', random_state=42)) # Modelo SVM com kernel RBF

])

'''

Definir espaço de busca para GridSearch

Busca combinatória dos melhores hiperparâmetros

'''

param_grid = {

'svm__C': [0.1, 1, 10, 100], # Valores de regularização

'svm__gamma': ['scale', 'auto', 0.1, 0.01], # Valores de gamma

'svm__kernel': ['rbf', 'linear'] # Tipos de kernel

}

print("\nIniciando busca de hiperparâmetros...")

# Executar GridSearch com validação cruzada

grid_search = GridSearchCV(pipeline, param_grid, cv=5, scoring='accuracy',

n_jobs=-1, verbose=1)

grid_search.fit(X_train, y_train)

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

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

# Fazer previsões com o melhor modelo

best_model = grid_search.best_estimator_

y_pred = best_model.predict(X_test)

# Avaliar o modelo

print("\nRelatório de Classificação:")

print(classification_report(y_test, y_pred))

# Análise dos resultados do GridSearch

results = grid_search.cv_results_

print(f"\nNúmero de combinações testadas: {len(results['params'])}")

# Visualizar performance dos diferentes parâmetros

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

# Extrair scores para kernel RBF

rbf_mask = [i for i, params in enumerate(results['params'])

if params['svm__kernel'] == 'rbf']

rbf_scores = results['mean_test_score'][rbf_mask]

plt.subplot(1, 2, 1)

plt.plot(range(len(rbf_scores)), rbf_scores, 'o-')

plt.title('Performance - Kernel RBF')

plt.xlabel('Combinação de Parâmetros')

plt.ylabel('Acurácia')

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# Análise dos vetores de suporte do melhor modelo

svm_model = best_model.named_steps['svm']

print(f"\nNúmero de vetores de suporte: {len(svm_model.support_vectors_)}")

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

Dicas Adicionais para Uso Prático

Embora os SVM sejam algoritmos poderosos, algumas considerações práticas são importantes:

Para Datasets Grandes

Utilize LinearSVC ou SGDClassifier
Considere redução de dimensionalidade com PCA
Use RandomizedSearchCV em vez de GridSearchCV
Ajuste o parâmetro cache_size para otimizar uso de memória

Para Datasets Desbalanceados

Utilize class_weight=’balanced’
Considere técnicas de reamostragem (SMOTE)
Avalie com métricas apropriadas (F1-score, ROC-AUC)

Otimização de Performance

Para kernels não-lineares, ajuste gamma adequadamente
Use n_jobs=-1 para paralelização quando possível
Considere warm_start=True para ajustes incrementais

Casos de Uso Recomendados

Os SVM são particularmente eficazes em:

Problemas com alta dimensionalidade
Quando o número de features é maior que o número de amostras
Problemas com limites de decisão complexos
Aplicações onde a generalização é crucial

Enfim, aplicar essas dicas práticas pode significativamente melhorar o desempenho e a robustez dos modelos SVM em projetos reais de machine learning.

Referência: https://scikit-learn.org/0.21/modules/svm.html#tips-on-practical-use