As Support Vector Machines (SVM) — Máquinas de Vetores de Suporte — são algoritmos de aprendizado supervisionado capazes de classificar e regressar dados. Em tarefas complexas (reconhecimento de caracteres, voz, imagens e faces), o SVM costuma superar algoritmos como Naive Bayes e Árvores de Decisão, embora exija mais configuração de parâmetros.

Ideia central: hiperplano com margem máxima

Em problemas de classificação binária, o SVM busca um hiperplano que separe as classes com a maior margem possível — a distância entre a linha (ou plano) de separação e os pontos mais próximos de cada lado.

Os pontos que definem essa margem são os vetores de suporte. O algoritmo aprende posicionando o hiperplano de forma que esses vetores fiquem o mais distante possível da fronteira de decisão.

        Classe A          |          Classe B
    o   o   o             |             x   x
        o                 |                 x
    o       o   ← vetor   |   vetor →   x       x
              de suporte  |  de suporte
    ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─┼─ ─ ─ ─ ─ ─ ─ ─ ─ ─
              margem      |      margem
                    hiperplano

Como o hiperplano é criado

Existem duas abordagens conceituais:

  1. Convex Hulls (cascos convexos): envolvem os pontos de cada classe; o hiperplano ótimo fica entre os cascos.
  2. Abordagem matemática (mais utilizada): resolve um problema de otimização que maximiza a margem sujeita a restrições de classificação correta.

O hiperplano de separação em duas dimensões pode ser expresso como:

w · x + b = 0

onde w é o vetor de pesos, x o ponto e b o termo de bias.

Erros e o parâmetro C

Em dados reais, a separação perfeita nem sempre é possível. Pontos classificados do lado errado do hiperplano geram erro proporcional à distância da reta.

O parâmetro C controla a punição por classificação incorreta:

  • C alto: o modelo tenta separar 100% dos pontos (margem menor, risco de overfitting).
  • C baixo: permite mais erros (margem maior, modelo mais tolerante).

O valor de C deve ser informado ao treinar o SVM e costuma ser ajustado por experimentação.

Problemas linearmente separáveis e não separáveis

ProblemaExemplo lógicoSeparável por reta?
AND(0,0)→0, (0,1)→0, (1,0)→0, (1,1)→1Sim
XOR(0,0)→0, (0,1)→1, (1,0)→1, (1,1)→0Não

Quando as classes não podem ser separadas por uma reta no espaço original, entra o Kernel Trick.

Kernel Trick: SVMs não lineares

O truque do kernel projeta os dados para um espaço de maior dimensão, onde a separação linear se torna possível — sem calcular explicitamente todas as transformações.

Exemplo: pontos (-3,9), (-2,4), (0,0), (1,1), (2,4), (3,9), (5,25) não são linearmente separáveis em x, mas ao elevar ao quadrado (x²) a separação fica viável.

Tipos de kernel mais usados no sklearn:

KernelUso típico
LinearDados já separáveis por reta/plano
PolinomialFronteiras curvas de grau configurável
RBF (Gausiano)Padrão para problemas não lineares
Sigmoid (Tangente Hiperbólica)Menos comum; inspirado em redes neurais

Cada kernel possui parâmetros próprios (ex.: gamma no RBF, degree no polinomial) que também precisam ser testados.

Vantagens e desvantagens

Vantagens

  • Robusto a ruídos (dependendo de C).
  • Serve para classificação e regressão (SVR).
  • Aprende conceitos não presentes diretamente nos dados originais (via kernels e variáveis de folga).
  • Mais simples de configurar que redes neurais profundas.

Desvantagens

  • Exige testar combinações de kernel e parâmetro C (e gamma).
  • Pode ser lento em bases muito grandes.

Implementação em Python (Scikit-learn)

  • Classe: SVC (classificação) e SVR (regressão).
  • Treinamento (fit): encontra o hiperplano e os vetores de suporte.
  • Previsão (predict): classifica novas entradas.
  • Avaliação (accuracy_score): mede a taxa de acerto no conjunto de teste.

Parâmetros importantes:

  • kernel: 'linear', 'poly', 'rbf' ou 'sigmoid'.
  • C: penalidade por erro de classificação.
  • gamma: influência de cada exemplo no RBF (apenas para kernels não lineares).

Talk is cheap, show me the code: Bases utilizadas nesta aula (disponíveis no Google Drive): credito.pkl · creditoSE.pkl · censo.pkl

Roteiro para a aula de Aprendizado Supervisionado - SVM ( Support Vector Machines)
1 – Executar a importação das bibliotecas (pode ser no mesmo arquivo da semana passada):

#biblioteca para gerar gráficos dinâmicos
!pip install plotly --upgrade
#pandas é uma biblioteca que trabalha com a importação de arquivos .csv
import pandas as pd
#numpy é uma biblioteca para a realização de operações em arrays
import numpy as np
#seaborn é uma biblioteca para vizualização de gráficos
import seaborn as sb
#matplotlib é também uma biblioteca para a geração de gráficos
import matplotlib.pyplot as plt
import plotly.express as px

===========================PARTE I - BASE DE DADOS CRÉDITO - ESCALONADA ========================================
1 - Importar o arquivo .pkl salvo na aula aterior (quem não tiver, pegar o enviado pelo professor)
import pickle
with open('/content/drive/MyDrive/Colab Notebooks/credito.pkl', 'rb') as f:
  X_credito_treinamento, Y_credito_treinamento, X_credito_teste, Y_credito_teste = pickle.load(f)


2 - Importar a biblioteca para trabalhar com o algoritmo SVM

from sklearn.svm import SVC #biblioteca para algoritmo SVM

3 - Criar a variável svm_credito para trabalhar com o algoritmo SVM e configurar seus parâmetros (testar com kernel linear, rbf e poly, combinados com parÂmetro c = 1, 10 e 100)
svm_credito = SVC(kernel='rbf', random_state=1, C=2)
svm_credito.fit(X_credito_treinamento, Y_credito_treinamento) # função que realiza o treinamento

#previsões
previsao = svm_credito.predict(X_credito_teste)


from sklearn.metrics import accuracy_score, classification_report #faz a comparação entre o que o algoritmo previu e o que a classe teste possui
accuracy_score(Y_credito_teste, previsao)

4 - Outra forma de comparação - Matriz de confusão

from yellowbrick.classifier import ConfusionMatrix
cm = ConfusionMatrix(svm_credito)
cm.fit(X_credito_treinamento, Y_credito_treinamento)
cm.score(X_credito_teste, Y_credito_teste)

print(classification_report(Y_credito_teste, previsao))

===========================PARTE II - BASE DE DADOS CRÉDITO - ESCALONADA ========================================
1 - Importar o arquivo .pkl salvo na aula aterior (quem não tiver, pegar o enviado pelo professor)
import pickle
with open('/content/drive/MyDrive/Colab Notebooks/creditoSE.pkl', 'rb') as f:
  X_credito_treinamentoSE, Y_credito_treinamentoSE, X_credito_testeSE, Y_credito_testeSE = pickle.load(f)


2 - Importar a biblioteca para trabalhar com o algoritmo SVM

from sklearn.svm import SVC #biblioteca para algoritmo SVM

3 - Criar a variável svm_credito para trabalhar com o algoritmo SVM e configurar seus parâmetros (testar com kernel linear, rbf e poly, combinados com parÂmetro c = 1, 10 e 100)
svm_creditoSE = SVC(kernel='rbf', random_state=1, C=2)
svm_creditoSE.fit(X_credito_treinamentoSE, Y_credito_treinamentoSE) # função que realiza o treinamento

#previsões
previsaoSE = svm_creditoSE.predict(X_credito_testeSE)


from sklearn.metrics import accuracy_score, classification_report #faz a comparação entre o que o algoritmo previu e o que a classe teste possui
accuracy_score(Y_credito_testeSE, previsaoSE)

4 - Outra forma de comparação - Matriz de confusão

from yellowbrick.classifier import ConfusionMatrix
cm = ConfusionMatrix(svm_creditoSE)
cm.fit(X_credito_treinamentoSE, Y_credito_treinamentoSE)
cm.score(X_credito_testeSE, Y_credito_testeSE)

print(classification_report(Y_credito_testeSE, previsaoSE))



=============================================== PARTE III - BASE DE DADOS CENSO - ESCALONADA ========================================================================
1 - Importar o arquivo .pkl salvo na aula aterior (quem não tiver, pegar o enviado pelo professor)
import pickle
with open('/content/drive/MyDrive/Colab Notebooks/censo.pkl', 'rb') as f:
  X_censo_treinamento, Y_censo_treinamento, X_censo_teste, Y_censo_teste = pickle.load(f)


2 - Importar a biblioteca para trabalhar com o algoritmo SVM

from sklearn.svm import SVC #biblioteca para algoritmo SVM

3 - Criar a variável svm_credito para trabalhar com o algoritmo SVM e configurar seus parâmetros
svm_censo = SVC(kernel='rbf', random_state=1, C=2)
svm_censo.fit(X_censo_treinamento, Y_censo_treinamento) # função que realiza o treinamento

#previsões
previsao = svm_censo.predict(X_censo_teste)


from sklearn.metrics import accuracy_score, classification_report #faz a comparação entre o que o algoritmo previu e o que a classe teste possui
accuracy_score(Y_censo_teste, previsao)

4 - Outra forma de comparação - Matriz de confusão

from yellowbrick.classifier import ConfusionMatrix
cm = ConfusionMatrix(svm_censo)
cm.fit(X_censo_treinamento, Y_censo_treinamento)
cm.score(X_censo_teste, Y_censo_teste)

print(classification_report(Y_censo_teste, previsao))

print(confusion_matrix(Y_censo_teste, previsoes))