Tutorial de máquinas de vetor de suporte com o Scikit-learn

O SVM é um algoritmo interessante e os conceitos são relativamente simples. O classificador separa os pontos de dados usando um hiperplano com a maior quantidade de margem. É por isso que um classificador SVM também é conhecido como classificador discriminativo. O SVM encontra um hiperplano ideal que ajuda a classificar novos pontos de dados.

Neste tutorial, você abordará os seguintes tópicos:

• Máquinas de vetor de suporte
• Como isso funciona?
• Núcleos
• Criação de classificadores no Scikit-learn
• Ajuste dos hiperparâmetros
• Vantagens e desvantagens

Assista e saiba mais sobre Support Vector Machines com o Scikit-learn neste vídeo do nosso curso.

Máquinas de vetor de suporte

Em geral, as máquinas de vetor de suporte são consideradas uma abordagem de classificação, mas podem ser empregadas em ambos os tipos de problemas de classificação e regressão. Ele pode lidar facilmente com diversas variáveis contínuas e categóricas. O SVM constrói um hiperplano no espaço multidimensional para separar classes diferentes. O SVM gera um hiperplano ideal de forma iterativa, que é usado para minimizar um erro. A ideia central do SVM é encontrar um hiperplano marginal máximo (MMH) que melhor divida o conjunto de dados em classes.

Vetores de suporte

Os vetores de suporte são os pontos de dados que estão mais próximos do hiperplano. Esses pontos definirão melhor a linha de separação por meio do cálculo das margens. Esses pontos são mais relevantes para a construção do classificador.

Hiperplano

Um hiperplano é um plano de decisão que separa um conjunto de objetos com diferentes associações de classe.

Margem

Uma margem é um espaço entre as duas linhas nos pontos de classe mais próximos. Isso é calculado como a distância perpendicular da linha aos vetores de suporte ou aos pontos mais próximos. Se a margem for maior entre as classes, ela será considerada uma boa margem; uma margem menor é uma margem ruim.

Como o SVM funciona?

O principal objetivo é segregar o conjunto de dados fornecido da melhor maneira possível. A distância entre os dois pontos mais próximos é conhecida como margem. O objetivo é selecionar um hiperplano com a margem máxima possível entre os vetores de suporte no conjunto de dados fornecido. O SVM procura o hiperplano marginal máximo nas etapas a seguir:

1. Gerar hiperplanos que segreguem as classes da melhor maneira. Figura do lado esquerdo mostrando três hiperplanos: preto, azul e laranja. Aqui, o azul e o laranja têm maior erro de classificação, mas o preto está separando as duas classes corretamente.

2. Selecione o hiperplano direito com a segregação máxima dos dois pontos de dados mais próximos, conforme mostrado na figura do lado direito.

Lidar com planos não lineares e inseparáveis

Alguns problemas não podem ser resolvidos usando o hiperplano linear, conforme mostrado na figura abaixo (lado esquerdo).

Nessa situação, o SVM usa um truque de kernel para transformar o espaço de entrada em um espaço de dimensão mais alta, conforme mostrado à direita. Os pontos de dados são plotados nos eixos x e z (Z é a soma ao quadrado de x e y: z=x^2=y^2). Agora você pode segregar facilmente esses pontos usando a separação linear.

SVM Kernels

O algoritmo SVM é implementado na prática usando um kernel. Um kernel transforma um espaço de dados de entrada no formato necessário. O SVM usa uma técnica chamada de truque do kernel. Aqui, o kernel pega um espaço de entrada de baixa dimensão e o transforma em um espaço de dimensão mais alta. Em outras palavras, você pode dizer que ele converte problemas não separáveis em problemas separáveis, acrescentando mais dimensão a eles. Ele é mais útil em problemas de separação não linear. O truque do kernel ajuda você a criar um classificador mais preciso.

• Kernel linear Um kernel linear pode ser usado como produto de ponto normal de duas observações dadas. O produto entre dois vetores é a soma da multiplicação de cada par de valores de entrada.

K(x, xi) = sum(x * xi)

• Kernel polinomial Um kernel polinomial é uma forma mais generalizada do kernel linear. O kernel polinomial pode distinguir espaços de entrada curvos ou não lineares.

K(x,xi) = 1 + sum(x * xi)^d

Onde d é o grau do polinômio. d=1 é semelhante à transformação linear. O grau precisa ser especificado manualmente no algoritmo de aprendizado.

• Kernel de função de base radial O kernel de função de base radial é uma função de kernel popular comumente usada na classificação de máquinas de vetor de suporte. A RBF pode mapear um espaço de entrada em um espaço dimensional infinito.

K(x,xi) = exp(-gamma * sum((x – xi^2))

Aqui, gamma é um parâmetro, que varia de 0 a 1. Um valor mais alto de gama se ajustará perfeitamente ao conjunto de dados de treinamento, o que causa um ajuste excessivo. Gamma=0,1 é considerado um bom valor padrão. O valor de gamma precisa ser especificado manualmente no algoritmo de aprendizado.

Criação de classificadores no Scikit-learn

Até agora, você aprendeu sobre a base teórica do SVM. Agora você aprenderá sobre sua implementação em Python usando o scikit-learn.

Na parte de construção do modelo, você pode usar o conjunto de dados de câncer, que é um problema de classificação multiclasse muito famoso. Esse conjunto de dados é calculado a partir de uma imagem digitalizada de um aspirado por agulha fina (FNA) de uma massa mamária. Eles descrevem as características dos núcleos celulares presentes na imagem.

O conjunto de dados inclui 30 recursos (raio médio, textura média, perímetro médio, área média, suavidade média, compacidade média, concavidade média, pontos côncavos médios, simetria média, dimensão fractal média, erro de raio, erro de textura, erro de perímetro, erro de área, erro de suavidade, erro de compacidade, erro de concavidade, erro de pontos côncavos, erro de simetria, erro de dimensão fractal, pior raio, pior textura, pior perímetro, pior área, pior suavidade, pior compactação, pior concavidade, piores pontos côncavos, pior simetria e pior dimensão fractal) e um alvo (tipo de câncer).

Esses dados têm dois tipos de classes de câncer: maligno (prejudicial) e benigno (não prejudicial). Aqui, você pode criar um modelo para classificar o tipo de câncer. O conjunto de dados está disponível na biblioteca scikit-learn ou você também pode baixá-lo da Biblioteca de aprendizado de máquina da UCI.

Carregando dados

Primeiro, vamos carregar o conjunto de dados necessário que você usará.

#Import scikit-learn dataset library
from sklearn import datasets

#Load dataset
cancer = datasets.load_breast_cancer()

Explorando dados

Depois de carregar o conjunto de dados, você pode querer saber um pouco mais sobre ele. Você pode verificar os nomes dos recursos e dos alvos.

# print the names of the 13 features
print("Features: ", cancer.feature_names)

# print the label type of cancer('malignant' 'benign')
print("Labels: ", cancer.target_names)

Features:  ['mean radius' 'mean texture' 'mean perimeter' 'mean area'
 'mean smoothness' 'mean compactness' 'mean concavity'
 'mean concave points' 'mean symmetry' 'mean fractal dimension'
 'radius error' 'texture error' 'perimeter error' 'area error'
 'smoothness error' 'compactness error' 'concavity error'
 'concave points error' 'symmetry error' 'fractal dimension error'
 'worst radius' 'worst texture' 'worst perimeter' 'worst area'
 'worst smoothness' 'worst compactness' 'worst concavity'
 'worst concave points' 'worst symmetry' 'worst fractal dimension']
Labels:  ['malignant' 'benign']

Vamos explorá-lo um pouco mais. Você também pode verificar a forma do conjunto de dados usando shape.

# print data(feature)shape
cancer.data.shape

(569, 30)

Vamos verificar os 5 principais registros do conjunto de recursos.

# print the cancer data features (top 5 records)
print(cancer.data[0:5])

[[1.799e+01 1.038e+01 1.228e+02 1.001e+03 1.184e-01 2.776e-01 3.001e-01
  1.471e-01 2.419e-01 7.871e-02 1.095e+00 9.053e-01 8.589e+00 1.534e+02
  6.399e-03 4.904e-02 5.373e-02 1.587e-02 3.003e-02 6.193e-03 2.538e+01
  1.733e+01 1.846e+02 2.019e+03 1.622e-01 6.656e-01 7.119e-01 2.654e-01
  4.601e-01 1.189e-01]
 [2.057e+01 1.777e+01 1.329e+02 1.326e+03 8.474e-02 7.864e-02 8.690e-02
  7.017e-02 1.812e-01 5.667e-02 5.435e-01 7.339e-01 3.398e+00 7.408e+01
  5.225e-03 1.308e-02 1.860e-02 1.340e-02 1.389e-02 3.532e-03 2.499e+01
  2.341e+01 1.588e+02 1.956e+03 1.238e-01 1.866e-01 2.416e-01 1.860e-01
  2.750e-01 8.902e-02]
 [1.969e+01 2.125e+01 1.300e+02 1.203e+03 1.096e-01 1.599e-01 1.974e-01
  1.279e-01 2.069e-01 5.999e-02 7.456e-01 7.869e-01 4.585e+00 9.403e+01
  6.150e-03 4.006e-02 3.832e-02 2.058e-02 2.250e-02 4.571e-03 2.357e+01
  2.553e+01 1.525e+02 1.709e+03 1.444e-01 4.245e-01 4.504e-01 2.430e-01
  3.613e-01 8.758e-02]
 [1.142e+01 2.038e+01 7.758e+01 3.861e+02 1.425e-01 2.839e-01 2.414e-01
  1.052e-01 2.597e-01 9.744e-02 4.956e-01 1.156e+00 3.445e+00 2.723e+01
  9.110e-03 7.458e-02 5.661e-02 1.867e-02 5.963e-02 9.208e-03 1.491e+01
  2.650e+01 9.887e+01 5.677e+02 2.098e-01 8.663e-01 6.869e-01 2.575e-01
  6.638e-01 1.730e-01]
 [2.029e+01 1.434e+01 1.351e+02 1.297e+03 1.003e-01 1.328e-01 1.980e-01
  1.043e-01 1.809e-01 5.883e-02 7.572e-01 7.813e-01 5.438e+00 9.444e+01
  1.149e-02 2.461e-02 5.688e-02 1.885e-02 1.756e-02 5.115e-03 2.254e+01
  1.667e+01 1.522e+02 1.575e+03 1.374e-01 2.050e-01 4.000e-01 1.625e-01
  2.364e-01 7.678e-02]]

Vamos dar uma olhada no conjunto de metas.

# print the cancer labels (0:malignant, 1:benign)
print(cancer.target)

[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 1 0 0 0 0 0 0 0 0 1 0 1 1 1 1 1 0 0 1 0 0 1 1 1 1 0 1 0 0 1 1 1 1 0 1 0 0
 1 0 1 0 0 1 1 1 0 0 1 0 0 0 1 1 1 0 1 1 0 0 1 1 1 0 0 1 1 1 1 0 1 1 0 1 1
 1 1 1 1 1 1 0 0 0 1 0 0 1 1 1 0 0 1 0 1 0 0 1 0 0 1 1 0 1 1 0 1 1 1 1 0 1
 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 1 0 1 1 0 0 1 1 0 0 1 1 1 1 0 1 1 0 0 0 1 0
 1 0 1 1 1 0 1 1 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 1 1 0 1 0 0 0 0 1 1 0 0 1 1
 1 0 1 1 1 1 1 0 0 1 1 0 1 1 0 0 1 0 1 1 1 1 0 1 1 1 1 1 0 1 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 0 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1
 1 0 1 1 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 0 1 1 1 1 0 0 0 1 1
 1 1 0 1 0 1 0 1 1 1 0 1 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0
 0 1 0 0 1 1 1 1 1 0 1 1 1 1 1 0 1 1 1 0 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 1 1
 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1 0 1 1 1 1 1 0 1 1
 0 1 0 1 1 0 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 1
 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 0 0 1 0 1 0 1 1 1 1 1 0 1 1 0 1 0 1 0 0
 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 0 0 0 0 0 0 1]

Divisão de dados

Para entender o desempenho do modelo, dividir o conjunto de dados em um conjunto de treinamento e um conjunto de teste é uma boa estratégia.

Divida o conjunto de dados usando a função train_test_split(). você precisa passar 3 parâmetros: recursos, alvo e tamanho do conjunto de teste. Além disso, você pode usar random_state para selecionar registros aleatoriamente.

# Import train_test_split function
from sklearn.model_selection import train_test_split

# Split dataset into training set and test set
X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, test_size=0.3,random_state=109) # 70% training and 30% test

Modelo de geração

Vamos criar um modelo de máquina de vetor de suporte. Primeiro, importe o módulo SVM e crie o objeto classificador de vetor de suporte passando o argumento kernel como o kernel linear na função SVC().

Em seguida, ajuste seu modelo no conjunto de treinamento usando fit() e faça a previsão no conjunto de teste usando predict().

#Import svm model
from sklearn import svm

#Create a svm Classifier
clf = svm.SVC(kernel='linear') # Linear Kernel

#Train the model using the training sets
clf.fit(X_train, y_train)

#Predict the response for test dataset
y_pred = clf.predict(X_test)

Avaliação do modelo

Vamos estimar a precisão com que o classificador ou modelo pode prever o câncer de mama das pacientes.

A precisão pode ser calculada comparando-se os valores reais do conjunto de testes e os valores previstos.

#Import scikit-learn metrics module for accuracy calculation
from sklearn import metrics

# Model Accuracy: how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))

Accuracy: 0.9649122807017544

Bem, você obteve uma taxa de classificação de 96,49%, considerada uma precisão muito boa.

Para avaliação adicional, você também pode verificar a precisão e a recuperação do modelo.

# Model Precision: what percentage of positive tuples are labeled as such?
print("Precision:",metrics.precision_score(y_test, y_pred))

# Model Recall: what percentage of positive tuples are labelled as such?
print("Recall:",metrics.recall_score(y_test, y_pred))

Precision: 0.9811320754716981
Recall: 0.9629629629629629

Bem, você obteve uma precisão de 98% e uma recuperação de 96%, que são considerados valores muito bons.

Ajuste dos hiperparâmetros

• Kernel: A principal função do kernel é transformar os dados de entrada do conjunto de dados fornecido na forma necessária. Há vários tipos de funções, como linear, polinomial e função de base radial (RBF). Polinomial e RBF são úteis para hiperplanos não lineares. Os núcleos polinomiais e RBF calculam a linha de separação na dimensão superior. Em alguns aplicativos, sugere-se o uso de um kernel mais complexo para separar as classes que são curvas ou não lineares. Essa transformação pode levar a classificadores mais precisos.

• Regularização: Parâmetro de regularização no parâmetro Scikit-learn C do python usado para manter a regularização. Aqui C é o parâmetro de penalidade, que representa a classificação incorreta ou o termo de erro. O termo de erro ou classificação incorreta informa à otimização do SVM a quantidade de erro suportável. É assim que você pode controlar a compensação entre o limite de decisão e o termo de classificação incorreta. Um valor menor de C cria um hiperplano de margem pequena e um valor maior de C cria um hiperplano de margem maior.
• Gamma: Um valor mais baixo de gama se ajustará livremente ao conjunto de dados de treinamento, ao passo que um valor mais alto de gama se ajustará exatamente ao conjunto de dados de treinamento, o que causa um ajuste excessivo. Em outras palavras, você pode dizer que um valor baixo de gama considera apenas os pontos próximos no cálculo da linha de separação, enquanto um valor de gama considera todos os pontos de dados no cálculo da linha de separação.

Vantagens

Os classificadores SVM oferecem boa precisão e fazem previsões mais rápidas em comparação com o algoritmo Naïve Bayes. Eles também usam menos memória porque usam um subconjunto de pontos de treinamento na fase de decisão. O SVM funciona bem com uma margem clara de separação e com espaço de alta dimensão.

Desvantagens

O SVM não é adequado para grandes conjuntos de dados devido ao seu alto tempo de treinamento e também leva mais tempo para ser treinado em comparação com o Naïve Bayes. Ele funciona mal com classes sobrepostas e também é sensível ao tipo de kernel usado.

Conclusão

Parabéns, você chegou ao final deste tutorial!

Neste tutorial, você cobriu muitas informações sobre o algoritmo de máquina de vetor de suporte, seu funcionamento, kernels, ajuste de hiperparâmetros, criação e avaliação de modelos no conjunto de dados de câncer de mama usando o pacote Scikit-learn. Você também abordou suas vantagens e desvantagens. Espero que você tenha aprendido algo valioso!

Para saber mais sobre esse tipo de classificadores, você deve dar uma olhada em nosso curso Classificadores lineares em Python. Ele apresenta outros tipos de funções de regressão e perda, bem como Support Vector Machines.

Aguardo ansiosamente qualquer comentário ou pergunta. Você pode fazer a pergunta deixando um comentário e eu farei o possível para respondê-la.