Máquina de Vetores de Suporte com Python¶

Realizando a classificação de uma base de dados do censo usando o método máquinas de vetores de suporte (SVM) com a linguagem de programação Python.¶

Pré-processamento dos dados¶

In [1]:

# importando a biblioteca pandas do python
import pandas as pd

# atribuindo os registros da base de dados para o objeto "dataframe"
dataframe = pd.read_csv('census.csv', encoding = 'utf-8', sep = ',')

# separando os atributos previsores e classe 
previsores = dataframe.iloc[:, 0:14].values
classe = dataframe.iloc[:, 14].values

# importando a biblioteca sklearn do python
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
# LabelEncoder é uma função responsável por  normalizar rótulos
# o objetivo é transoformar variáveis categóricas em numéricas
# função "OneHotEncoder" responsável por fazer a trasnformação em variáveis "dummy"

# importando a biblioteca sklearn do python
from sklearn.compose import ColumnTransformer
# função "ColumnTransformer" responsável por definir quais colunas o objeto irá agir na alteração

# criando o objeto "labelencoder_previsores" para fazer a transformação dos atributos categóricos em numéricos
labelencoder_previsores = LabelEncoder()

# aplicando a transformação em todos os campos de dados categóricos usando o objeto criado e definido 
# "LabelEncoder_previsores"
previsores[:,1] = labelencoder_previsores.fit_transform(previsores[:,1])
previsores[:,3] = labelencoder_previsores.fit_transform(previsores[:,3])
previsores[:,5] = labelencoder_previsores.fit_transform(previsores[:,5])
previsores[:,6] = labelencoder_previsores.fit_transform(previsores[:,6])
previsores[:,7] = labelencoder_previsores.fit_transform(previsores[:,7])
previsores[:,8] = labelencoder_previsores.fit_transform(previsores[:,8])
previsores[:,9] = labelencoder_previsores.fit_transform(previsores[:,9])
previsores[:,13] = labelencoder_previsores.fit_transform(previsores[:,13])

# criando e configurando o objeto onehotencoder
onehotencoder = ColumnTransformer(transformers = [('OneHot', OneHotEncoder(), [1,3,5,6,7,8,9,13])], 
                                  remainder = 'passthrough')

# transformando os atributos previsores em variáveis do tipo "dummy"
previsores = onehotencoder.fit_transform(previsores).toarray()

# importando a biblioteca sklearn do python
from sklearn.preprocessing import StandardScaler

# criando e configurando o objeto "scaler"
scaler = StandardScaler()

# aplicando o escaolonamento nos atributos previsores
previsores = scaler.fit_transform(previsores)

# importando a biblioteca sklearn do python
from sklearn.model_selection import train_test_split
# a função "train_test_split" tem a função de separar modelos de treinamento e modelos de teste em uma base 
#de dados

# separando as bases de dados entre modelos de treinamento e modelos de teste
previsores_treinamento, previsores_teste, classe_treinamento, classe_teste = train_test_split(previsores, 
                                                                                             classe,
                                                                                             test_size = 0.15, 
                                                                                             random_state = 0)

OBS = Esse foi o melhor pré-processamento feito na base de dados para obter bons resultados.

Máquinas de Vetores de Suporte com Python (kernel linear)¶

In [8]:

# importando a biblioteca sklearn do python
from sklearn.svm import SVC
# função 'SVC' responsável pela apicação do algoritmo SVM

In [3]:

# criando o objeto classificador e configurando-o para a treinamento usando o SVM
classificador = SVC(kernel = 'linear', random_state = 1)

In [4]:

# fazendo o treinamento do algoritmo usando a base de dados e o objeto criado
classificador.fit(previsores_treinamento, classe_treinamento)

Out[4]:

SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape='ovr', degree=3, gamma='scale', kernel='linear',
    max_iter=-1, probability=False, random_state=1, shrinking=True, tol=0.001,
    verbose=False)

In [5]:

# realizando a predição usando o algoritmo e uma base de dados para teste
previsoes = classificador.predict(previsores_teste)

In [6]:

# observando a saída de dados obtida pelo algoritmo com a base de dados de teste
print(previsoes)

[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' >50K']

In [7]:

# observando a saída de dados original para a base de dados de teste
print(classe_teste)

[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' <=50K']

Analisando a capacidade de predição do algoritmo (kernel linear)¶

In [9]:

# importando a biblioteca sklearn do python
from sklearn.metrics import accuracy_score, confusion_matrix

In [10]:

# obtendo a precisão de acertos do algoritmo
precisao = accuracy_score(classe_teste, previsoes)

In [11]:

# analisando a precisão de acertos do algoritmo
print(precisao)

0.8507676560900717

O algoritmo (kernel linear) teve uma precisão de acertos de 85.07%.

In [12]:

# obtendo a matriz de confusão das predições feitas pelo algoritmo
matriz = confusion_matrix(classe_teste, previsoes)

In [13]:

# analisando a matriz de confusão das predições feitas pelo algoritmo
print(matriz)

[[3459  234]
 [ 495  697]]

Observando a matriz de confusão acima, 3459 dados relativos a pessoas que recebem menos que 50 mil por ano foram classificados corretamente, juntamente com 697 dados para pessoas que recebem a mais que essa quantia. Entretanto, 234 dados relativos a pessoas que recebem menos que a quantia em questão foram classificados de forma incorreta como se recebessem mais que isso, assim como 495 dados relativos a pessoas que recebem a mais foram classificadas incorretamente como se recebessem menos.

Máquinas de Vetores de Suporte com Python (kernel poly)¶

In [14]:

# importando a biblioteca sklearn do python
from sklearn.svm import SVC
# função 'SVC' responsável pela apicação do algoritmo SVM

In [15]:

# criando o objeto classificador e configurando-o para a treinamento usando o SVM
classificador = SVC(kernel = 'poly', random_state = 1)

In [16]:

# fazendo o treinamento do algoritmo usando a base de dados e o objeto criado
classificador.fit(previsores_treinamento, classe_treinamento)

Out[16]:

SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape='ovr', degree=3, gamma='scale', kernel='poly',
    max_iter=-1, probability=False, random_state=1, shrinking=True, tol=0.001,
    verbose=False)

In [17]:

# realizando a predição usando o algoritmo e uma base de dados para teste
previsoes = classificador.predict(previsores_teste)

In [18]:

# observando a saída de dados obtida pelo algoritmo com a base de dados de teste
print(previsoes)

[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' >50K']

In [19]:

# observando a saída de dados original para a base de dados de teste
print(classe_teste)

[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' <=50K']

Analisando a capacidade de predição do algoritmo (kernel poly)¶

In [20]:

# importando a biblioteca sklearn do python
from sklearn.metrics import accuracy_score, confusion_matrix

In [21]:

# obtendo a precisão de acertos do algoritmo
precisao = accuracy_score(classe_teste, previsoes)

In [22]:

# analisando a precisão de acertos do algoritmo
print(precisao)

0.8296827021494371

A precisão de acertos para o algoritmo (kernel poly) foi de 82.96%.

In [23]:

# obtendo a matriz de confusão das predições feitas pelo algoritmo
matriz = confusion_matrix(classe_teste, previsoes)

In [24]:

# analisando a matriz de confusão das predições feitas pelo algoritmo
print(matriz)

[[3478  215]
 [ 617  575]]

Observando a matriz de confusão acima, 3478 dados relativos a pessoas que recebem menos que 50 mil por ano foram classificados corretamente, juntamente com 575 dados para pessoas que recebem a mais que essa quantia. Entretanto, 215 dados relativos a pessoas que recebem menos que a quantia em questão foram classificados de forma incorreta como se recebessem mais que isso, assim como 617 dados relativos a pessoas que recebem a mais foram classificadas incorretamente como se recebessem menos.

Máquinas de Vetores de Suporte com Python (kernel sigmoid)¶

In [25]:

# importando a biblioteca sklearn do python
from sklearn.svm import SVC
# função 'SVC' responsável pela apicação do algoritmo SVM

In [26]:

# criando o objeto classificador e configurando-o para a treinamento usando o SVM
classificador = SVC(kernel = 'sigmoid', random_state = 1)

In [27]:

# fazendo o treinamento do algoritmo usando a base de dados e o objeto criado
classificador.fit(previsores_treinamento, classe_treinamento)

Out[27]:

SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape='ovr', degree=3, gamma='scale', kernel='sigmoid',
    max_iter=-1, probability=False, random_state=1, shrinking=True, tol=0.001,
    verbose=False)

In [28]:

# realizando a predição usando o algoritmo e uma base de dados para teste
previsoes = classificador.predict(previsores_teste)

In [29]:

# observando a saída de dados obtida pelo algoritmo com a base de dados de teste
print(previsoes)

[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' >50K']

In [30]:

# observando a saída de dados original para a base de dados de teste
print(classe_teste)

[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' <=50K']

Analisando a capacidade de predição do algoritmo (kernel sigmoid)¶

In [31]:

# importando a biblioteca sklearn do python
from sklearn.metrics import accuracy_score, confusion_matrix

In [32]:

# obtendo a precisão de acertos do algoritmo
precisao = accuracy_score(classe_teste, previsoes)

In [33]:

# analisando a precisão de acertos do algoritmo
print(precisao)

0.8216990788126919

A capacidade de predição do algoritmo (kernel sigmoid) foi de 82.16%.

In [34]:

# obtendo a matriz de confusão das predições feitas pelo algoritmo
matriz = confusion_matrix(classe_teste, previsoes)

In [35]:

# analisando a matriz de confusão das predições feitas pelo algoritmo
print(matriz)

[[3341  352]
 [ 519  673]]

Observando a matriz de confusão acima, 3341 dados relativos a pessoas que recebem menos que 50 mil por ano foram classificados corretamente, juntamente com 673 dados para pessoas que recebem a mais que essa quantia. Entretanto, 352 dados relativos a pessoas que recebem menos que a quantia em questão foram classificados de forma incorreta como se recebessem mais que isso, assim como 519 dados relativos a pessoas que recebem a mais foram classificadas incorretamente como se recebessem menos.

Máquinas de Vetores de Suporte com Python (kernel rbf)¶

In [36]:

# importando a biblioteca sklearn do python
from sklearn.svm import SVC
# função 'SVC' responsável pela apicação do algoritmo SVM

In [37]:

# criando o objeto classificador e configurando-o para a treinamento usando o SVM
classificador = SVC(kernel = 'rbf', random_state = 1)

In [38]:

# fazendo o treinamento do algoritmo usando a base de dados e o objeto criado
classificador.fit(previsores_treinamento, classe_treinamento)

Out[38]:

SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',
    max_iter=-1, probability=False, random_state=1, shrinking=True, tol=0.001,
    verbose=False)

In [39]:

# realizando a predição usando o algoritmo e uma base de dados para teste
previsoes = classificador.predict(previsores_teste)

In [40]:

# observando a saída de dados obtida pelo algoritmo com a base de dados de teste
print(previsoes)

[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' >50K']

In [41]:

# observando a saída de dados original para a base de dados de teste
print(classe_teste)

[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' <=50K']

Analisando a capacidade de predição do algoritmo (kernel rbf)¶

In [42]:

# importando a biblioteca sklearn do python
from sklearn.metrics import accuracy_score, confusion_matrix

In [43]:

# obtendo a precisão de acertos do algoritmo
precisao = accuracy_score(classe_teste, previsoes)

In [44]:

# analisando a precisão de acertos do algoritmo
print(precisao)

0.8493346980552713

O algoritmo de classificação pelo método SVM (kernel rbf) obteve uma precisão de acertos de 84.93%.

In [45]:

# obtendo a matriz de confusão das predições feitas pelo algoritmo
matriz = confusion_matrix(classe_teste, previsoes)

In [46]:

# analisando a matriz de confusão das predições feitas pelo algoritmo
print(matriz)

[[3470  223]
 [ 513  679]]

Observando a matriz de confusão acima, 3470 dados relativos a pessoas que recebem menos que 50 mil por ano foram classificados corretamente, juntamente com 679 dados para pessoas que recebem a mais que essa quantia. Entretanto, 223 dados relativos a pessoas que recebem menos que a quantia em questão foram classificados de forma incorreta como se recebessem mais que isso, assim como 513 dados relativos a pessoas que recebem a mais foram classificadas incorretamente como se recebessem menos.

Observando o balaceamento das classes¶

In [47]:

# importando a biblioteca collections do python
import collections

In [48]:

# visualizando a quantidade de registros para cada uma das classes
collections.Counter(classe_teste)

Out[48]:

Counter({' <=50K': 3693, ' >50K': 1192})

Alguma dúvida? Entre em contato comigo:¶

Me envie um e-mail;