Máquinas de Vetores de Suporte

Máquinas de Vetores de Suporte (SVMs): Machine Learning em Python

Posts Relacionados:

IA em Python com regressão logística

Conheça o kNN, um algoritmo intuitivo e versátil

Machine learning descomplicada com a biblioteca scikit-learn

28.08.24

Máquinas de Vetores de Suporte são modelos versáteis e altamente eficientes de machine learning. Conheça suas bases, aplicações e implementação descomplicada com Python.

Receba nossa newsletter

Máquinas de vetores de suporte (SVMs)

Máquinas de vetores de suporte (Support Vector Machines, SVMs) são poderosos modelos de aprendizagem supervisionada usados principalmente para tarefas de classificação. Além de classificações, SVMs realizam regressões e detecções de outliers. SVMs usam hiperplanos para separar diferentes classes em um espaço de alta dimensão.

Máquinas de vetores de suporte se destacam em tarefas de classificação binária. Eles também têm aplicações para cenários multiclasse por meio de técnicas como One-vs-Rest.

Como as máquinas de vetores de suporte funcionam?

Em essência, SVMs constroem hiperplanos no espaço N-dimensional (onde N é o número de recursos). Para tarefas de classificação, um SVM encontra um limite de decisão resolvendo um problema de otimização. Seu objetivo é maximizar a margem entre os vetores de suporte de duas classes. Vetores de suporte são os pontos de dados mais próximos de um limite de decisão.

O hiperplano de separação ideal é determinado durante a fase de treinamento do algoritmo. Uma vez treinado, o algoritmo consegue prever a classificação de novos pontos de dados sem ter sido explicitamente programado para classificá-los com antecedência.

Algoritmos de SVMs são comumente separados em diferentes tipos:

SVM linear: usado quando os dados são linearmente separáveis, o que significa que uma linha reta pode efetivamente separar suas classes.

SVM não linear: utiliza funções de kernel para lidar com dados que não são linearmente separáveis, mapeando-os em um espaço de dimensão superior.

Breve Explicação da Matemática do Algoritmo

A ideia principal das máquinas de vetores de suporte é maximizar a margem entre as classes, a qual é a distância perpendicular de um hiperplano aos pontos de dados mais próximos (vetores de suporte). Considerando o caso mais simples em que os dados são linearmente separáveis, o hiperplano pode ser representado pela equação:

w^T⋅x + b = 0

onde w é o vetor normal ao hiperplano, x é um ponto do conjunto de dados e b é o termo de viés. O objetivo do treinamento de um SVM é encontrar valores de w e b que maximizam a margem. A margem é calculada como:

margem = |w^T⋅ x + b| / ||w||

Para maximizar a margem, é preciso minimizar ||w|| considerando à restrição de que todos os pontos de dados sejam classificados corretamente, o que é descrito pela equação:

y_i(w^T⋅x_i + b) ≥ 1

onde y_i é o rótulo do ponto de dados x_i. Este é um problema de otimização quadrática sujeito a restrições lineares, e que possui um único mínimo.

Esquema representando mais de um hiperplano de separação em um SVM (à esquerda). À direita, o hiperplano ao centro é perpendicular ao vetor w. A margem $γ$ representa a distância entre o hiperplano e os vetores de suporte (fonte).

Os principais componentes dos SVMs

SVMs possuem alguns componentes principais. Eles são listados a seguir.

Hiperplanos

Para um SVM, um hiperplano é um limite de decisão que separa os pontos de dados de diferentes classes em um espaço de recursos. No caso de classificações lineares, o hiperplano será uma equação linear.

Vetores de Suporte

Os pontos de dados que estão mais próximos do(s) limite(s) de decisão são conhecidos como vetores de suporte. Eles desempenham um papel crítico na decisão do hiperplano e da margem.

Margem

Margem é a distância entre os vetores de suporte e o hiperplano. O principal objetivo do algoritmo da máquina de vetores de suporte é maximizar a margem. A margem mais ampla indica melhor desempenho de classificação.

Kernels

Geralmente, especialmente ao trabalhar com dados não linearmente separáveis, o SVM emprega o conceito de kernels. Kernels são métodos matemáticos que transformam os pontos de dados de entrada originais em espaços de recursos de alta dimensão. Isso facilita a identificação de hiperplanos mesmo quando os pontos de dados não são linearmente separáveis no espaço de entrada original. Algumas das funções comuns do kernel são kernel linear, polinomial, função de base radial (RBF) e sigmóide.

Margem Rígida (Hard Margin)

O hiperplano de margem rígida é um hiperplano que separa adequadamente os pontos de dados de diferentes categorias sem classificações incorretas.

Margem Flexível (Soft Margin)

Quando os dados não são perfeitamente separáveis ou contêm valores discrepantes, o SVM pode ser implementado com margem flexível. Nesta versão do algoritmo, cada ponto de dados tem uma variável de folga. Isso permite a ocorrência de algumas classificações incorretas.

Regularização

A regularização auxilia as máquinas de vetores de suporte a evitarem o overfitting. Ela introduz um termo de penalidade (C) que equilibra a largura da margem e o número de vetores de suporte usados. A penalidade por ultrapassar a margem ou classificar incorretamente os itens de dados é decidida por esse parâmetro. Uma penalidade mais rigorosa é imposta com um valor maior de C.

Máquinas de vetores de suporte: etapas de implementação

Veja as etapas comuns envolvidas na implementação de uma máquina de vetores de suporte:

Compreensão do problema: identifique a tarefa e prepare conjuntos de dados relevantes.
Colete e prepare os dados: obtenha um conjunto de dados, realize análises exploratórias e divida-o em conjuntos de treinamento e teste.
Escolha uma função de kernel: selecione uma função de kernel apropriada para o seu problema específico:

Kernel linear: adequado para dados separáveis linearmente.
Kernel polinomial: pode lidar com relacionamentos não lineares.
Kernel Radial Basis Function (RBF): escolha popular para muitas aplicações.
Kernel Sigmóide: menos comumente usado, mas pode ser eficaz em certos casos.

Seleção de parâmetros: selecione os parâmetros cruciais para o algoritmo SVM:

Parâmetro C: regula o trade-off entre maximizar a margem e minimizar os erros de classificação.
Parâmetro do kernel (se aplicável): controla o comportamento da função do kernel (por exemplo, parametro gama para o kernel RBF).

Crie o modelo SVM: crie uma instância do Support Vector Classifier (SVC) usando scikit-learn.
Avaliação do modelo: teste o SVM em um conjunto de validação/teste para avaliar seu desempenho.

SVM em código

Para exemplificar como o SVM pode ser implementado na prática, o utilizaremos para classificar o conjunto de dados MNIST. O MNIST é um conjunto de dados bastante tradicional para tarefas de classificação. Ele consiste em imagens de dígitos de 0 a 9 escritos a mão. O objetivo do modelo é aprender a classificar as imagens corretamente. Para realizar essa tarefa, utilizaremos a biblioteca scikit-learn. Ela já conta com o MNIST. Portanto, primeiro importamos os métodos que utilizaremos e o conjunto de dados:

				
					
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn import svm
from sklearn.metrics import accuracy_score

# Correga MNIST
dados = datasets.load_digits()

Em seguida, dividimos o conjunto de dados em recursos (X) e rótulos (y). As imagens no conjunto de recursos são convertidas em vetores:

				
					
# separa atributos e rótulos
X = dados.images.reshape((len(dados.images), -1)) # converte as imagens em vetores
y = dados.target

Depois, dividimos o conjunto de dados em conjunto de treinamento e teste:

				
					
# Divide os dados
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=00.25)

A etapa seguinte é a criação de uma instância do SVM:

				
					# Cria o classificador
clf = svm.SVC(gamma='scale')

Após isso, realizamos o treinamento:

				
					# Treina o modelo
clf.fit(X_train, y_train)

Por fim, validamos o modelo usando o conjunto de testes:

				
					# Realiza predições no conjunto de teste
pred = clf.predict(X_test)

# Verifica acurácia
print("Acurácia:", accuracy_score(y_test, pred)*100, "%")
# Output: Acurácia: 98.22222222222223 %