{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Máquina de Vetores de Suporte com Python\n",
"#### 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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Pré-processamento dos dados"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# importando a biblioteca pandas do python\n",
"import pandas as pd\n",
"\n",
"# atribuindo os registros da base de dados para o objeto \"dataframe\"\n",
"dataframe = pd.read_csv('census.csv', encoding = 'utf-8', sep = ',')\n",
"\n",
"# separando os atributos previsores e classe \n",
"previsores = dataframe.iloc[:, 0:14].values\n",
"classe = dataframe.iloc[:, 14].values\n",
"\n",
"# importando a biblioteca sklearn do python\n",
"from sklearn.preprocessing import LabelEncoder, OneHotEncoder\n",
"# LabelEncoder é uma função responsável por normalizar rótulos\n",
"# o objetivo é transoformar variáveis categóricas em numéricas\n",
"# função \"OneHotEncoder\" responsável por fazer a trasnformação em variáveis \"dummy\"\n",
"\n",
"# importando a biblioteca sklearn do python\n",
"from sklearn.compose import ColumnTransformer\n",
"# função \"ColumnTransformer\" responsável por definir quais colunas o objeto irá agir na alteração\n",
"\n",
"# criando o objeto \"labelencoder_previsores\" para fazer a transformação dos atributos categóricos em numéricos\n",
"labelencoder_previsores = LabelEncoder()\n",
"\n",
"# aplicando a transformação em todos os campos de dados categóricos usando o objeto criado e definido \n",
"# \"LabelEncoder_previsores\"\n",
"previsores[:,1] = labelencoder_previsores.fit_transform(previsores[:,1])\n",
"previsores[:,3] = labelencoder_previsores.fit_transform(previsores[:,3])\n",
"previsores[:,5] = labelencoder_previsores.fit_transform(previsores[:,5])\n",
"previsores[:,6] = labelencoder_previsores.fit_transform(previsores[:,6])\n",
"previsores[:,7] = labelencoder_previsores.fit_transform(previsores[:,7])\n",
"previsores[:,8] = labelencoder_previsores.fit_transform(previsores[:,8])\n",
"previsores[:,9] = labelencoder_previsores.fit_transform(previsores[:,9])\n",
"previsores[:,13] = labelencoder_previsores.fit_transform(previsores[:,13])\n",
"\n",
"# criando e configurando o objeto onehotencoder\n",
"onehotencoder = ColumnTransformer(transformers = [('OneHot', OneHotEncoder(), [1,3,5,6,7,8,9,13])], \n",
" remainder = 'passthrough')\n",
"\n",
"# transformando os atributos previsores em variáveis do tipo \"dummy\"\n",
"previsores = onehotencoder.fit_transform(previsores).toarray()\n",
"\n",
"# importando a biblioteca sklearn do python\n",
"from sklearn.preprocessing import StandardScaler\n",
"\n",
"# criando e configurando o objeto \"scaler\"\n",
"scaler = StandardScaler()\n",
"\n",
"# aplicando o escaolonamento nos atributos previsores\n",
"previsores = scaler.fit_transform(previsores)\n",
"\n",
"# importando a biblioteca sklearn do python\n",
"from sklearn.model_selection import train_test_split\n",
"# a função \"train_test_split\" tem a função de separar modelos de treinamento e modelos de teste em uma base \n",
"#de dados\n",
"\n",
"# separando as bases de dados entre modelos de treinamento e modelos de teste\n",
"previsores_treinamento, previsores_teste, classe_treinamento, classe_teste = train_test_split(previsores, \n",
" classe,\n",
" test_size = 0.15, \n",
" random_state = 0)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"> **OBS** = Esse foi o melhor pré-processamento feito na base de dados para obter bons resultados."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Máquinas de Vetores de Suporte com Python (kernel linear)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"# importando a biblioteca sklearn do python\n",
"from sklearn.svm import SVC\n",
"# função 'SVC' responsável pela apicação do algoritmo SVM"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"# criando o objeto classificador e configurando-o para a treinamento usando o SVM\n",
"classificador = SVC(kernel = 'linear', random_state = 1)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,\n",
" decision_function_shape='ovr', degree=3, gamma='scale', kernel='linear',\n",
" max_iter=-1, probability=False, random_state=1, shrinking=True, tol=0.001,\n",
" verbose=False)"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# fazendo o treinamento do algoritmo usando a base de dados e o objeto criado\n",
"classificador.fit(previsores_treinamento, classe_treinamento)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# realizando a predição usando o algoritmo e uma base de dados para teste\n",
"previsoes = classificador.predict(previsores_teste)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' >50K']\n"
]
}
],
"source": [
"# observando a saída de dados obtida pelo algoritmo com a base de dados de teste\n",
"print(previsoes)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' <=50K']\n"
]
}
],
"source": [
"# observando a saída de dados original para a base de dados de teste\n",
"print(classe_teste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Analisando a capacidade de predição do algoritmo (kernel linear)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"# importando a biblioteca sklearn do python\n",
"from sklearn.metrics import accuracy_score, confusion_matrix"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"# obtendo a precisão de acertos do algoritmo\n",
"precisao = accuracy_score(classe_teste, previsoes)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.8507676560900717\n"
]
}
],
"source": [
"# analisando a precisão de acertos do algoritmo\n",
"print(precisao)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"O algoritmo (kernel linear) teve uma precisão de acertos de **85.07%**."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"# obtendo a matriz de confusão das predições feitas pelo algoritmo\n",
"matriz = confusion_matrix(classe_teste, previsoes)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[3459 234]\n",
" [ 495 697]]\n"
]
}
],
"source": [
"# analisando a matriz de confusão das predições feitas pelo algoritmo\n",
"print(matriz)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Máquinas de Vetores de Suporte com Python (kernel poly)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"# importando a biblioteca sklearn do python\n",
"from sklearn.svm import SVC\n",
"# função 'SVC' responsável pela apicação do algoritmo SVM"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"# criando o objeto classificador e configurando-o para a treinamento usando o SVM\n",
"classificador = SVC(kernel = 'poly', random_state = 1)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,\n",
" decision_function_shape='ovr', degree=3, gamma='scale', kernel='poly',\n",
" max_iter=-1, probability=False, random_state=1, shrinking=True, tol=0.001,\n",
" verbose=False)"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# fazendo o treinamento do algoritmo usando a base de dados e o objeto criado\n",
"classificador.fit(previsores_treinamento, classe_treinamento)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"# realizando a predição usando o algoritmo e uma base de dados para teste\n",
"previsoes = classificador.predict(previsores_teste)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' >50K']\n"
]
}
],
"source": [
"# observando a saída de dados obtida pelo algoritmo com a base de dados de teste\n",
"print(previsoes)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' <=50K']\n"
]
}
],
"source": [
"# observando a saída de dados original para a base de dados de teste\n",
"print(classe_teste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Analisando a capacidade de predição do algoritmo (kernel poly)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"# importando a biblioteca sklearn do python\n",
"from sklearn.metrics import accuracy_score, confusion_matrix"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"# obtendo a precisão de acertos do algoritmo\n",
"precisao = accuracy_score(classe_teste, previsoes)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.8296827021494371\n"
]
}
],
"source": [
"# analisando a precisão de acertos do algoritmo\n",
"print(precisao)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A precisão de acertos para o algoritmo (kernel poly) foi de **82.96%**."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"# obtendo a matriz de confusão das predições feitas pelo algoritmo\n",
"matriz = confusion_matrix(classe_teste, previsoes)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[3478 215]\n",
" [ 617 575]]\n"
]
}
],
"source": [
"# analisando a matriz de confusão das predições feitas pelo algoritmo\n",
"print(matriz)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Máquinas de Vetores de Suporte com Python (kernel sigmoid)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"# importando a biblioteca sklearn do python\n",
"from sklearn.svm import SVC\n",
"# função 'SVC' responsável pela apicação do algoritmo SVM"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"# criando o objeto classificador e configurando-o para a treinamento usando o SVM\n",
"classificador = SVC(kernel = 'sigmoid', random_state = 1)"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,\n",
" decision_function_shape='ovr', degree=3, gamma='scale', kernel='sigmoid',\n",
" max_iter=-1, probability=False, random_state=1, shrinking=True, tol=0.001,\n",
" verbose=False)"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# fazendo o treinamento do algoritmo usando a base de dados e o objeto criado\n",
"classificador.fit(previsores_treinamento, classe_treinamento)"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"# realizando a predição usando o algoritmo e uma base de dados para teste\n",
"previsoes = classificador.predict(previsores_teste)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' >50K']\n"
]
}
],
"source": [
"# observando a saída de dados obtida pelo algoritmo com a base de dados de teste\n",
"print(previsoes)"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' <=50K']\n"
]
}
],
"source": [
"# observando a saída de dados original para a base de dados de teste\n",
"print(classe_teste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Analisando a capacidade de predição do algoritmo (kernel sigmoid)"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [],
"source": [
"# importando a biblioteca sklearn do python\n",
"from sklearn.metrics import accuracy_score, confusion_matrix"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [],
"source": [
"# obtendo a precisão de acertos do algoritmo\n",
"precisao = accuracy_score(classe_teste, previsoes)"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.8216990788126919\n"
]
}
],
"source": [
"# analisando a precisão de acertos do algoritmo\n",
"print(precisao)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A capacidade de predição do algoritmo (kernel sigmoid) foi de **82.16%**."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [],
"source": [
"# obtendo a matriz de confusão das predições feitas pelo algoritmo\n",
"matriz = confusion_matrix(classe_teste, previsoes)"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[3341 352]\n",
" [ 519 673]]\n"
]
}
],
"source": [
"# analisando a matriz de confusão das predições feitas pelo algoritmo\n",
"print(matriz)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Máquinas de Vetores de Suporte com Python (kernel rbf)"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [],
"source": [
"# importando a biblioteca sklearn do python\n",
"from sklearn.svm import SVC\n",
"# função 'SVC' responsável pela apicação do algoritmo SVM"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [],
"source": [
"# criando o objeto classificador e configurando-o para a treinamento usando o SVM\n",
"classificador = SVC(kernel = 'rbf', random_state = 1)"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,\n",
" decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',\n",
" max_iter=-1, probability=False, random_state=1, shrinking=True, tol=0.001,\n",
" verbose=False)"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# fazendo o treinamento do algoritmo usando a base de dados e o objeto criado\n",
"classificador.fit(previsores_treinamento, classe_treinamento)"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [],
"source": [
"# realizando a predição usando o algoritmo e uma base de dados para teste\n",
"previsoes = classificador.predict(previsores_teste)"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' >50K']\n"
]
}
],
"source": [
"# observando a saída de dados obtida pelo algoritmo com a base de dados de teste\n",
"print(previsoes)"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[' <=50K' ' <=50K' ' <=50K' ... ' <=50K' ' <=50K' ' <=50K']\n"
]
}
],
"source": [
"# observando a saída de dados original para a base de dados de teste\n",
"print(classe_teste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Analisando a capacidade de predição do algoritmo (kernel rbf)"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [],
"source": [
"# importando a biblioteca sklearn do python\n",
"from sklearn.metrics import accuracy_score, confusion_matrix"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [],
"source": [
"# obtendo a precisão de acertos do algoritmo\n",
"precisao = accuracy_score(classe_teste, previsoes)"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.8493346980552713\n"
]
}
],
"source": [
"# analisando a precisão de acertos do algoritmo\n",
"print(precisao)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"O algoritmo de classificação pelo método SVM (kernel rbf) obteve uma precisão de acertos de **84.93%**."
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [],
"source": [
"# obtendo a matriz de confusão das predições feitas pelo algoritmo\n",
"matriz = confusion_matrix(classe_teste, previsoes)"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[3470 223]\n",
" [ 513 679]]\n"
]
}
],
"source": [
"# analisando a matriz de confusão das predições feitas pelo algoritmo\n",
"print(matriz)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Observando o balaceamento das classes"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [],
"source": [
"# importando a biblioteca collections do python\n",
"import collections"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Counter({' <=50K': 3693, ' >50K': 1192})"
]
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# visualizando a quantidade de registros para cada uma das classes\n",
"collections.Counter(classe_teste)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Alguma dúvida? Entre em contato comigo:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- [Me envie um e-mail](mailto:alysson.barbosa@ee.ufcg.edu.br);"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.4"
}
},
"nbformat": 4,
"nbformat_minor": 4
}