Implementando outros tipos de SVM com o Scikit-Learn do Python

Introdução

Este guia é a terceira e última parte de três guias sobre Support Vector Machines (SVMs). Neste guia, continuaremos trabalhando com o caso de uso de notas bancárias falsificadas, faremos uma rápida recapitulação sobre a ideia geral por trás dos SVMs, entenderemos qual é o truque do kernel e implementaremos diferentes tipos de kernels não lineares com o Scikit-Learn.

Na série completa de guias SVM, além de aprender sobre outros tipos de SVMs, você também aprenderá sobre SVM simples, parâmetros pré-definidos SVM, hiperparâmetros C e Gamma e como eles podem ser ajustados com pesquisa de grade e validação cruzada.

Se você deseja ler os guias anteriores, pode dar uma olhada nos dois primeiros guias ou ver quais tópicos mais lhe interessam. Abaixo está a tabela de tópicos abordados em cada guia:

1. Implementando SVM e Kernel SVM com Scikit-Learn do Python

• Caso de uso: esqueça notas bancárias
• Histórico de SVMs
• Modelo SVM Simples (Linear)
  • Sobre o conjunto de dados
  • Importando o conjunto de dados
  • Explorando o conjunto de dados
• Implementando SVM com Scikit-Learn
  • Dividindo dados em conjuntos de treinamento/teste
  • Treinando o modelo
  • Fazendo previsões
  • Avaliando o Modelo
  • Interpretando os resultados

2. Compreendendo os hiperparâmetros do SVM

• O Hiperparâmetro C
• O Hiperparâmetro Gama

3. Implementando outros tipos de SVM com Scikit-Learn do Python

• A ideia geral de SVMs (uma recapitulação)
• Kernel (Truque) SVM
• Implementando Kernel SVM Não Linear com Scikit-Learn
• Importando Bibliotecas
  • Importando o conjunto de dados
  • Dividindo dados em recursos (X) e destino (y)
  • Dividindo dados em conjuntos de treinamento/teste
  • Treinando o Algoritmo
• núcleo polinomial
  • Fazendo previsões
  • Avaliando o Algoritmo
• Kernel gaussiano
  • Previsão e avaliação
• Núcleo Sigmoide
  • Previsão e avaliação
• Comparação de Desempenhos de Kernel Não Lineares

Vamos lembrar do que se trata o SVM antes de ver algumas variações interessantes do kernel do SVM.

A ideia geral dos SVMs

No caso de dados linearmente separáveis ​​em duas dimensões (como mostrado na Fig. 1), a abordagem típica do algoritmo de aprendizado de máquina seria tentar encontrar um limite que divida os dados de forma que o erro de classificação incorreta seja minimizado. Se você observar atentamente a figura 1, observe que pode haver vários limites (infinitos) que dividem os pontos de dados corretamente. As duas linhas tracejadas, assim como a linha contínua, são classificações válidas dos dados.

Fig 1: Múltiplos Limites de Decisão

Quando o SVM escolhe o limite de decisão, ele escolhe um limite que maximiza a distância entre ele e os pontos de dados mais próximos das classes. Já sabemos que os pontos de dados mais próximos são os vetores de suporte e que a distância pode ser parametrizada tanto por C e gamma hiperparâmetros.

Ao calcular esse limite de decisão, o algoritmo escolhe quantos pontos considerar e até onde a margem pode ir – isso configura um problema de maximização de margem. Ao resolver esse problema de maximização de margem, o SVM usa os vetores de suporte (como visto na Fig. 2) e tenta descobrir quais são os valores ótimos que mantêm a distância da margem maior, enquanto classifica mais pontos corretamente de acordo com a função que está sendo usada para separar os dados.

Fig 2: Limite de decisão com vetores de suporte

É por isso que o SVM difere de outros algoritmos de classificação, pois não apenas encontra um limite de decisão, mas acaba encontrando o limite de decisão ótimo.

Existe uma matemática complexa derivada de estatísticas e métodos computacionais envolvidos na localização dos vetores de suporte, no cálculo da margem entre o limite de decisão e os vetores de suporte e na maximização dessa margem. Desta vez, não entraremos em detalhes sobre como a matemática funciona.

É sempre importante mergulhar mais fundo e garantir que os algoritmos de aprendizado de máquina não sejam algum tipo de feitiço misterioso, embora não conhecer todos os detalhes matemáticos neste momento não o impeça de executar o algoritmo e obter resultados.

Kernel (Truque) SVM

Na seção anterior, lembramos e organizamos a ideia geral do SVM – vendo como ele pode ser usado para encontrar o limite de decisão ideal para dados linearmente separáveis. No entanto, no caso de dados não separáveis ​​linearmente, como o mostrado na Fig. 3, já sabemos que uma linha reta não pode ser usada como limite de decisão.

Fig 3: Dados Separáveis ​​Não Linearmente

Em vez disso, podemos usar a versão modificada do SVM que discutimos no início, chamada Kernel SVM.

Basicamente, o que o kernel SVM fará é projetar os dados não linearmente separáveis ​​de dimensões inferiores para sua forma correspondente em dimensões superiores. Isso é um truque, porque ao projetar dados não linearmente separáveis ​​em dimensões maiores, a forma dos dados muda de forma que se torna separável. Por exemplo, ao pensar em 3 dimensões, os pontos de dados de cada classe podem acabar sendo alocados em uma dimensão diferente, tornando-a separável. Uma forma de aumentar as dimensões dos dados pode ser exponenciando-os. Novamente, há uma matemática complexa envolvida nisso, mas você não precisa se preocupar com isso para usar o SVM. Em vez disso, podemos usar a biblioteca Scikit-Learn do Python para implementar e usar os kernels não lineares da mesma forma que usamos o linear.

Implementando Kernel SVM Não Linear com Scikit-Learn

Nesta seção, usaremos o mesmo conjunto de dados para prever se uma cédula é real ou falsificada de acordo com as quatro características que já conhecemos.

Você verá que o restante das etapas são etapas típicas de aprendizado de máquina e precisam de muito pouca explicação até chegarmos à parte em que treinamos nossos SVMs de kernel não linear.

Importando Bibliotecas

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from sklearn.model_selection import train_test_split

Importando o conjunto de dados

data_link = "https://archive.ics.uci.edu/ml/machine-learning-databases/00267/data_banknote_authentication.txt"
col_names = ["variance", "skewness", "curtosis", "entropy", "class"] bankdata = pd.read_csv(data_link, names=col_names, sep=",", header=None)
bankdata.head()mes)

Dividindo dados em recursos (X) e destino (y)

X = bankdata.drop('class', axis=1)
y = bankdata['class']

Dividindo dados em conjuntos de treinamento/teste

SEED = 42 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = SEED)

Treinando o Algoritmo

Para treinar o kernel SVM, usaremos o mesmo SVC aula do Scikit-Learn's svm biblioteca. A diferença está no valor do parâmetro do kernel do SVC classe.

No caso do SVM simples, usamos “linear” como valor para o parâmetro do kernel. No entanto, como mencionamos anteriormente, para SVM de kernel, podemos usar kernels gaussianos, polinomiais, sigmoides ou computáveis. Implementaremos kernels polinomiais, gaussianos e sigmoides e examinaremos suas métricas finais para ver qual parece se adequar às nossas classes com uma métrica mais alta.

1. Núcleo polinomial

Em álgebra, um polinômio é uma expressão da forma:

$$
2a*b^3 + 4a – 9
$$

Isso tem variáveis, como a e b, constantes, em nosso exemplo, 9 e coeficientes (constantes acompanhadas de variáveis), como 2 e 4. O 3 é considerado o grau do polinômio.

Existem tipos de dados que podem ser melhor descritos ao usar uma função polinomial, aqui, o que o kernel fará é mapear nossos dados para um polinômio para o qual escolheremos o grau. Quanto maior o grau, mais a função tentará se aproximar dos dados, portanto, o limite de decisão é mais flexível (e mais propenso a superajuste) – quanto menor o grau, menos flexível.

Assim, para a implementação do núcleo polinomial, além de escolher o poly kernel, também passaremos um valor para o degree parâmetro do SVC aula. Abaixo está o código:

from sklearn.svm import SVC
svc_poly = SVC(kernel='poly', degree=8)
svc_poly.fit(X_train, y_train)

Fazendo previsões

Agora, uma vez que treinamos o algoritmo, o próximo passo é fazer previsões sobre os dados de teste.

Como fizemos antes, podemos executar o seguinte script para fazer isso:

y_pred_poly = svclassifier.predict(X_test)

Avaliando o Algoritmo

Como de costume, a etapa final é fazer avaliações no kernel polinomial. Como repetimos algumas vezes o código do relatório de classificação e da matriz de confusão, vamos transformá-lo em uma função que display_results depois de receber os respectivos y_test, y_pred e título para a matriz de confusão de Seaborn com cm_title:

def display_results(y_test, y_pred, cm_title): cm = confusion_matrix(y_test,y_pred) sns.heatmap(cm, annot=True, fmt='d').set_title(cm_title) print(classification_report(y_test,y_pred))

Agora, podemos chamar a função e ver os resultados obtidos com o kernel polinomial:

cm_title_poly = "Confusion matrix with polynomial kernel"
display_results(y_test, y_pred_poly, cm_title_poly)

A saída é semelhante a esta:

 precision recall f1-score support 0 0.69 1.00 0.81 148 1 1.00 0.46 0.63 127 accuracy 0.75 275 macro avg 0.84 0.73 0.72 275
weighted avg 0.83 0.75 0.73 275

Agora podemos repetir os mesmos passos para kernels gaussianos e sigmoides.

2. Núcleo Gaussiano

Para usar o kernel gaussiano, precisamos apenas especificar 'rbf' como valor para o kernel parâmetro da classe SVC:

svc_gaussian = SVC(kernel='rbf', degree=8)
svc_gaussian.fit(X_train, y_train)

Ao explorar ainda mais este kernel, você também pode usar a pesquisa em grade para combiná-lo com diferentes C e gamma valores.

Previsão e avaliação

y_pred_gaussian = svc_gaussian.predict(X_test)

cm_title_gaussian = "Confusion matrix with Gaussian kernel"
display_results(y_test, y_pred_gaussian, cm_title_gaussian)

A saída do kernel gaussiano SVM se parece com isto:

 precision recall f1-score support 0 1.00 1.00 1.00 148 1 1.00 1.00 1.00 127 accuracy 1.00 275 macro avg 1.00 1.00 1.00 275
weighted avg 1.00 1.00 1.00 275

3. Núcleo Sigmoide

Por fim, vamos usar um kernel sigmoid para implementar o Kernel SVM. Dê uma olhada no seguinte roteiro:

svc_sigmoid = SVC(kernel='sigmoid')
svc_sigmoid.fit(X_train, y_train)

Para usar o kernel sigmoid, você deve especificar 'sigmoid' como valor para o kernel parâmetro do SVC classe.

Previsão e avaliação

y_pred_sigmoid = svc_sigmoid.predict(X_test)

cm_title_sigmoid = "Confusion matrix with Sigmoid kernel"
display_results(y_test, y_pred_sigmoid, cm_title_sigmoid)

A saída do Kernel SVM com o kernel Sigmoid se parece com isto:

 precision recall f1-score support 0 0.67 0.71 0.69 148 1 0.64 0.59 0.61 127 accuracy 0.65 275 macro avg 0.65 0.65 0.65 275
weighted avg 0.65 0.65 0.65 275

Comparação de Desempenhos de Kernel Não Lineares

Se compararmos brevemente o desempenho dos diferentes tipos de kernels não lineares, pode parecer que o kernel sigmóide tem as métricas mais baixas, portanto, o pior desempenho.

Entre os kernels gaussianos e polinomiais, podemos ver que o kernel gaussiano alcançou uma taxa de predição perfeita de 100% – o que geralmente é suspeito e pode indicar um overfit, enquanto o kernel polinomial classificou incorretamente 68 instâncias da classe 1.

Portanto, não há uma regra rígida e rápida sobre qual kernel tem melhor desempenho em cada cenário ou em nosso cenário atual sem pesquisar mais por hiperparâmetros, entender sobre cada forma de função, explorar os dados e comparar os resultados de treinamento e teste para ver se o algoritmo está generalizando.

Trata-se de testar todos os kernels e selecionar aquele com a combinação de parâmetros e preparação de dados que dê os resultados esperados de acordo com o contexto do seu projeto.

Indo além – Projeto portátil de ponta a ponta

Sua natureza curiosa faz você querer ir mais longe? Recomendamos verificar nosso Projeto Guiado: “Previsão de preço de casa prática – Aprendizado de máquina em Python”.

Neste projeto guiado, você aprenderá a criar modelos tradicionais poderosos de aprendizado de máquina, bem como modelos de aprendizado profundo, utilizar o Ensemble Learning e treinar meta-alunos para prever os preços das casas a partir de uma sacola de modelos Scikit-Learn e Keras.

Usando Keras, a API de aprendizado profundo criada com base no Tensorflow, vamos experimentar arquiteturas, construir um conjunto de modelos empilhados e treinar um meta-aprendiz rede neural (modelo de nível 1) para descobrir o preço de uma casa.

O aprendizado profundo é incrível – mas antes de recorrer a ele, é aconselhável tentar também resolver o problema com técnicas mais simples, como aprendizagem superficial algoritmos. Nosso desempenho de linha de base será baseado em um Regressão da Floresta Aleatória algoritmo. Além disso, exploraremos a criação de conjuntos de modelos por meio do Scikit-Learn por meio de técnicas como ensacamento e votação.

Este é um projeto de ponta a ponta e, como todos os projetos de Machine Learning, começaremos com – com Análise exploratória de dados, Seguido por Pré-processamento de dados e finalmente Edifício Raso e Modelos de aprendizado profundo para ajustar os dados que exploramos e limpamos anteriormente.

Conclusão

Neste artigo, fizemos uma rápida recapitulação sobre SVMs, estudamos sobre o truque do kernel e implementamos diferentes tipos de SVMs não lineares.

Sugiro que você implemente cada kernel e continue avançando. Você pode explorar a matemática usada para criar cada um dos diferentes kernels, por que eles foram criados e as diferenças em relação a seus hiperparâmetros. Dessa forma, você aprenderá sobre as técnicas e qual tipo de kernel é melhor aplicar dependendo do contexto e dos dados disponíveis.

Ter uma compreensão clara de como cada kernel funciona e quando usá-los definitivamente o ajudará em sua jornada. Deixe-nos saber como está o progresso e codificação feliz!

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• Platoblockchain. Inteligência Metaverso Web3. Conhecimento Ampliado. Acesse aqui.
• Cunhando o Futuro com Adryenn Ashley. Acesse aqui.
• Fonte: https://stackabuse.com/implementing-other-svm-flavors-with-pythons-scikit-learn/