IA com Python - aprendizagem supervisionada: classificação

Neste capítulo, vamos nos concentrar na implementação da aprendizagem supervisionada - classificação.

A técnica ou modelo de classificação tenta obter alguma conclusão a partir dos valores observados. No problema de classificação, temos a saída categorizada como “Preto” ou “branco” ou “Ensino” e “Não Ensino”. Ao construir o modelo de classificação, precisamos ter um conjunto de dados de treinamento que contenha pontos de dados e os rótulos correspondentes. Por exemplo, se queremos verificar se a imagem é de um carro ou não. Para verificar isso, construiremos um conjunto de dados de treinamento tendo as duas classes relacionadas a “carro” e “sem carro”. Em seguida, precisamos treinar o modelo usando os exemplos de treinamento. Os modelos de classificação são usados principalmente em reconhecimento facial, identificação de spam, etc.

Etapas para construir um classificador em Python

Para construir um classificador em Python, vamos usar Python 3 e Scikit-learn, que é uma ferramenta para aprendizado de máquina. Siga estas etapas para construir um classificador em Python -

Etapa 1 - Importar Scikit-learn

Este seria o primeiro passo para construir um classificador em Python. Nesta etapa, instalaremos um pacote Python chamado Scikit-learn, que é um dos melhores módulos de aprendizado de máquina em Python. O seguinte comando nos ajudará a importar o pacote -

Import Sklearn

Etapa 2 - Importar o conjunto de dados do Scikit-learn

Nesta etapa, podemos começar a trabalhar com o conjunto de dados para nosso modelo de aprendizado de máquina. Aqui, vamos usarthe Breast Cancer Wisconsin Diagnostic Database. O conjunto de dados inclui várias informações sobre tumores de câncer de mama, bem como rótulos de classificação demalignant ou benign. O conjunto de dados tem 569 instâncias, ou dados, em 569 tumores e inclui informações sobre 30 atributos ou recursos, como o raio do tumor, textura, suavidade e área. Com a ajuda do seguinte comando, podemos importar o conjunto de dados de câncer de mama do Scikit-learn -

from sklearn.datasets import load_breast_cancer

Agora, o seguinte comando carregará o conjunto de dados.

data = load_breast_cancer()

A seguir está uma lista de chaves de dicionário importantes -

Nomes de rótulos de classificação (target_names)
Os rótulos reais (alvo)
Os nomes de atributos / recursos (feature_names)
O atributo (dados)

Agora, com a ajuda do seguinte comando, podemos criar novas variáveis para cada conjunto importante de informações e atribuir os dados. Em outras palavras, podemos organizar os dados com os seguintes comandos -

label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']

Agora, para deixar mais claro, podemos imprimir os rótulos da classe, o rótulo da primeira instância de dados, nossos nomes de recursos e o valor do recurso com a ajuda dos seguintes comandos -

print(label_names)

O comando acima imprimirá os nomes das classes que são malignas e benignas, respectivamente. É mostrado como a saída abaixo -

['malignant' 'benign']

Agora, o comando abaixo mostrará que eles são mapeados para valores binários 0 e 1. Aqui, 0 representa o câncer maligno e 1 representa o câncer benigno. Você receberá a seguinte saída -

print(labels[0])
0

Os dois comandos fornecidos a seguir produzirão os nomes e valores dos recursos.

print(feature_names[0])
mean radius
print(features[0])
[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
  1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
  2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
  8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
  5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
  2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
  1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
  4.60100000e-01 1.18900000e-01]

Na saída acima, podemos ver que a primeira instância de dados é um tumor maligno, cujo raio é 1.7990000e + 01.

Etapa 3 - Organização de dados em conjuntos

Nesta etapa, dividiremos nossos dados em duas partes, a saber, um conjunto de treinamento e um conjunto de teste. Dividir os dados nesses conjuntos é muito importante porque temos que testar nosso modelo nos dados não vistos. Para dividir os dados em conjuntos, sklearn tem uma função chamada detrain_test_split()função. Com a ajuda dos comandos a seguir, podemos dividir os dados nesses conjuntos -

from sklearn.model_selection import train_test_split

O comando acima irá importar o train_test_splitfunção do sklearn e o comando abaixo irá dividir os dados em dados de treinamento e teste. No exemplo abaixo, estamos usando 40% dos dados para teste e os dados restantes seriam usados para treinar o modelo.

train, test, train_labels, test_labels = train_test_split(features,labels,test_size = 0.40, random_state = 42)

Etapa 4 - Construindo o modelo

Nesta etapa, estaremos construindo nosso modelo. Vamos usar o algoritmo Naïve Bayes para construir o modelo. Os seguintes comandos podem ser usados para construir o modelo -

from sklearn.naive_bayes import GaussianNB

O comando acima importará o módulo GaussianNB. Agora, o comando a seguir o ajudará a inicializar o modelo.

gnb = GaussianNB()

Vamos treinar o modelo ajustando-o aos dados usando gnb.fit ().

model = gnb.fit(train, train_labels)

Etapa 5 - Avaliação do modelo e sua precisão

Nesta etapa, vamos avaliar o modelo fazendo previsões em nossos dados de teste. Então, descobriremos sua precisão também. Para fazer previsões, usaremos a função predict (). O seguinte comando irá ajudá-lo a fazer isso -

preds = gnb.predict(test)
print(preds)

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

As séries acima de 0s e 1s são os valores previstos para as classes de tumor - maligno e benigno.

Agora, comparando as duas matrizes, a saber test_labels e preds, podemos descobrir a precisão do nosso modelo. Vamos usar oaccuracy_score()função para determinar a precisão. Considere o seguinte comando para isso -

from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965

O resultado mostra que o classificador NaïveBayes tem 95,17% de precisão.

Desta forma, com a ajuda das etapas acima, podemos construir nosso classificador em Python.

Classificador de construção em Python

Nesta seção, aprenderemos como construir um classificador em Python.

Classificador Naïve Bayes

Naïve Bayes é uma técnica de classificação usada para construir classificadores usando o teorema de Bayes. O pressuposto é que os preditores são independentes. Em palavras simples, ele assume que a presença de um determinado recurso em uma classe não está relacionada à presença de qualquer outro recurso. Para construir o classificador Naïve Bayes, precisamos usar a biblioteca python chamada scikit learn. Existem três tipos de modelos Naïve Bayes chamadosGaussian, Multinomial and Bernoulli no pacote de aprendizado do scikit.

Para construir um modelo de classificador de aprendizado de máquina Naïve Bayes, precisamos do seguinte e menos

Conjunto de Dados

Usaremos o conjunto de dados denominado Breast Cancer Wisconsin Diagnostic Database. O conjunto de dados inclui várias informações sobre tumores de câncer de mama, bem como rótulos de classificação demalignant ou benign. O conjunto de dados tem 569 instâncias, ou dados, em 569 tumores e inclui informações sobre 30 atributos ou recursos, como o raio do tumor, textura, suavidade e área. Podemos importar este conjunto de dados do pacote sklearn.

Modelo Naïve Bayes

Para construir o classificador Naïve Bayes, precisamos de um modelo Naïve Bayes. Como dito anteriormente, existem três tipos de modelos Naïve Bayes chamadosGaussian, Multinomial e Bernoullino pacote de aprendizado do scikit. Aqui, no exemplo a seguir, vamos usar o modelo Gaussian Naïve Bayes.

Usando o acima, vamos construir um modelo de aprendizado de máquina Naïve Bayes para usar as informações do tumor para prever se um tumor é maligno ou benigno.

Para começar, precisamos instalar o módulo sklearn. Isso pode ser feito com a ajuda do seguinte comando -

Import Sklearn

Agora, precisamos importar o conjunto de dados denominado Breast Cancer Wisconsin Diagnostic Database.

from sklearn.datasets import load_breast_cancer

Agora, o seguinte comando carregará o conjunto de dados.

data = load_breast_cancer()

Os dados podem ser organizados da seguinte forma -

label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']

Agora, para deixar mais claro, podemos imprimir os rótulos da classe, o rótulo da primeira instância de dados, nossos nomes de recursos e o valor do recurso com a ajuda dos seguintes comandos -

print(label_names)

O comando acima imprimirá os nomes das classes que são malignas e benignas, respectivamente. É mostrado como a saída abaixo -

['malignant' 'benign']

Agora, o comando dado abaixo mostrará que eles são mapeados para valores binários 0 e 1. Aqui, 0 representa o câncer maligno e 1 representa o câncer benigno. É mostrado como a saída abaixo -

print(labels[0])
0

Os dois comandos a seguir produzirão os nomes e valores dos recursos.

print(feature_names[0])
mean radius
print(features[0])

[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
  1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
  2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
  8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
  5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
  2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
  1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
  4.60100000e-01 1.18900000e-01]

Na saída acima, podemos ver que a primeira instância de dados é um tumor maligno, cujo raio principal é 1.7990000e + 01.

Para testar nosso modelo em dados não vistos, precisamos dividir nossos dados em dados de treinamento e teste. Isso pode ser feito com a ajuda do seguinte código -

from sklearn.model_selection import train_test_split

train, test, train_labels, test_labels = 
train_test_split(features,labels,test_size = 0.40, random_state = 42)

Agora, estamos construindo o modelo com os seguintes comandos -

from sklearn.naive_bayes import GaussianNB

O comando acima irá importar o GaussianNBmódulo. Agora, com o comando fornecido a seguir, precisamos inicializar o modelo.

gnb = GaussianNB()

Vamos treinar o modelo ajustando-o aos dados usando gnb.fit().

model = gnb.fit(train, train_labels)

Agora, avalie o modelo fazendo previsões sobre os dados de teste e isso pode ser feito da seguinte maneira -

preds = gnb.predict(test)
print(preds)

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

As séries de 0s e 1s acima são os valores previstos para as classes de tumor, ou seja, maligno e benigno.

from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965

O resultado mostra que o classificador NaïveBayes tem 95,17% de precisão.

Esse era um classificador de aprendizado de máquina baseado no modelo Naïve Bayse Gaussian.

Support Vector Machines (SVM)

Basicamente, a máquina de vetores de suporte (SVM) é um algoritmo de aprendizado de máquina supervisionado que pode ser usado para regressão e classificação. O conceito principal do SVM é plotar cada item de dados como um ponto no espaço n-dimensional com o valor de cada recurso sendo o valor de uma coordenada específica. Aqui n seriam os recursos que teríamos. A seguir está uma representação gráfica simples para entender o conceito de SVM -

No diagrama acima, temos dois recursos. Portanto, primeiro precisamos representar graficamente essas duas variáveis em um espaço bidimensional onde cada ponto tem duas coordenadas, chamadas de vetores de suporte. A linha divide os dados em dois grupos classificados diferentes. Essa linha seria o classificador.

Aqui, vamos construir um classificador SVM usando o conjunto de dados scikit-learn e iris. A biblioteca Scikitlearn tem osklearn.svmmódulo e fornece sklearn.svm.svc para classificação. O classificador SVM para prever a classe da planta da íris com base em 4 recursos é mostrado abaixo.

Conjunto de Dados

Usaremos o conjunto de dados da íris que contém 3 classes de 50 instâncias cada, onde cada classe se refere a um tipo de planta da íris. Cada instância tem quatro características, a saber, comprimento da sépala, largura da sépala, comprimento e largura da pétala. O classificador SVM para prever a classe da planta da íris com base em 4 recursos é mostrado abaixo.

Núcleo

É uma técnica usada por SVM. Basicamente, essas são as funções que pegam o espaço de entrada de baixa dimensão e o transformam em um espaço de dimensão superior. Ele converte um problema não separável em um problema separável. A função kernel pode ser qualquer uma entre linear, polinomial, rbf e sigmóide. Neste exemplo, usaremos o kernel linear.

Vamos agora importar os seguintes pacotes -

import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as plt

Agora, carregue os dados de entrada -

iris = datasets.load_iris()

Estamos pegando os dois primeiros recursos -

X = iris.data[:, :2]
y = iris.target

Traçaremos os limites da máquina de vetores de suporte com os dados originais. Estamos criando uma malha para plotar.

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
h = (x_max / x_min)/100
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
X_plot = np.c_[xx.ravel(), yy.ravel()]

Precisamos fornecer o valor do parâmetro de regularização.

C = 1.0

Precisamos criar o objeto classificador SVM.

Svc_classifier = svm_classifier.SVC(kernel='linear', 
C=C, decision_function_shape = 'ovr').fit(X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize = (15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap = plt.cm.tab10, alpha = 0.3)
plt.scatter(X[:, 0], X[:, 1], c = y, cmap = plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('SVC with linear kernel')

Regressão Logística

Basicamente, o modelo de regressão logística é um dos membros da família de algoritmos de classificação supervisionada. A regressão logística mede a relação entre variáveis dependentes e variáveis independentes, estimando as probabilidades usando uma função logística.

Aqui, se falamos sobre variáveis dependentes e independentes, então a variável dependente é a variável da classe-alvo que vamos prever e, por outro lado, as variáveis independentes são os recursos que vamos usar para prever a classe-alvo.

Na regressão logística, estimar as probabilidades significa prever a probabilidade de ocorrência do evento. Por exemplo, o dono da loja gostaria de prever que o cliente que entrou na loja comprará a play station (por exemplo) ou não. Haveria muitas características do cliente - sexo, idade, etc. que seriam observadas pelo lojista para prever a probabilidade de ocorrência, ou seja, comprar ou não uma play station. A função logística é a curva sigmóide que é usada para construir a função com vários parâmetros.

Pré-requisitos

Antes de construir o classificador usando regressão logística, precisamos instalar o pacote Tkinter em nosso sistema. Pode ser instalado a partir dehttps://docs.python.org/2/library/tkinter.html.

Agora, com a ajuda do código fornecido a seguir, podemos criar um classificador usando regressão logística -

Primeiro, vamos importar alguns pacotes -

import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt

Agora, precisamos definir os dados de amostra, o que pode ser feito da seguinte forma -

X = np.array([[2, 4.8], [2.9, 4.7], [2.5, 5], [3.2, 5.5], [6, 5], [7.6, 4],
              [3.2, 0.9], [2.9, 1.9],[2.4, 3.5], [0.5, 3.4], [1, 4], [0.9, 5.9]])
y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3])

Em seguida, precisamos criar o classificador de regressão logística, o que pode ser feito da seguinte maneira -

Classifier_LR = linear_model.LogisticRegression(solver = 'liblinear', C = 75)

Por último, mas não menos importante, precisamos treinar este classificador -

Classifier_LR.fit(X, y)

Agora, como podemos visualizar a saída? Isso pode ser feito criando uma função chamada Logistic_visualize () -

Def Logistic_visualize(Classifier_LR, X, y):
   min_x, max_x = X[:, 0].min() - 1.0, X[:, 0].max() + 1.0
   min_y, max_y = X[:, 1].min() - 1.0, X[:, 1].max() + 1.0

Na linha acima, definimos os valores mínimo e máximo de X e Y a serem usados na grade da malha. Além disso, definiremos o tamanho do passo para traçar a grade da malha.

mesh_step_size = 0.02

Vamos definir a grade de malha dos valores X e Y da seguinte maneira -

x_vals, y_vals = np.meshgrid(np.arange(min_x, max_x, mesh_step_size),
                 np.arange(min_y, max_y, mesh_step_size))

Com a ajuda do código a seguir, podemos executar o classificador na grade da malha -

output = classifier.predict(np.c_[x_vals.ravel(), y_vals.ravel()])
output = output.reshape(x_vals.shape)
plt.figure()
plt.pcolormesh(x_vals, y_vals, output, cmap = plt.cm.gray)
 
plt.scatter(X[:, 0], X[:, 1], c = y, s = 75, edgecolors = 'black', 
linewidth=1, cmap = plt.cm.Paired)

A seguinte linha de código irá especificar os limites do gráfico

plt.xlim(x_vals.min(), x_vals.max())
plt.ylim(y_vals.min(), y_vals.max())
plt.xticks((np.arange(int(X[:, 0].min() - 1), int(X[:, 0].max() + 1), 1.0)))
plt.yticks((np.arange(int(X[:, 1].min() - 1), int(X[:, 1].max() + 1), 1.0)))
plt.show()

Agora, depois de executar o código, obteremos a seguinte saída, classificador de regressão logística -

Classificador de árvore de decisão

Uma árvore de decisão é basicamente um fluxograma de árvore binária onde cada nó divide um grupo de observações de acordo com alguma variável de recurso.

Aqui, estamos construindo um classificador de árvore de decisão para prever homens ou mulheres. Vamos pegar um conjunto de dados muito pequeno com 19 amostras. Essas amostras consistiriam em duas características - 'altura' e 'comprimento do cabelo'.

Pré-requisito

Para construir o seguinte classificador, precisamos instalar pydotplus e graphviz. Basicamente, graphviz é uma ferramenta para desenhar gráficos usando arquivos de ponto epydotplusé um módulo para a linguagem Dot do Graphviz. Ele pode ser instalado com o gerenciador de pacotes ou pip.

Agora, podemos construir o classificador da árvore de decisão com a ajuda do seguinte código Python -

Para começar, vamos importar algumas bibliotecas importantes da seguinte maneira -

import pydotplus
from sklearn import tree
from sklearn.datasets import load_iris
from sklearn.metrics import classification_report
from sklearn import cross_validation
import collections

Agora, precisamos fornecer o conjunto de dados da seguinte forma -

X = [[165,19],[175,32],[136,35],[174,65],[141,28],[176,15],[131,32],
[166,6],[128,32],[179,10],[136,34],[186,2],[126,25],[176,28],[112,38],
[169,9],[171,36],[116,25],[196,25]]

Y = ['Man','Woman','Woman','Man','Woman','Man','Woman','Man','Woman',
'Man','Woman','Man','Woman','Woman','Woman','Man','Woman','Woman','Man']
data_feature_names = ['height','length of hair']

X_train, X_test, Y_train, Y_test = cross_validation.train_test_split
(X, Y, test_size=0.40, random_state=5)

Depois de fornecer o conjunto de dados, precisamos ajustar o modelo, o que pode ser feito da seguinte maneira -

clf = tree.DecisionTreeClassifier()
clf = clf.fit(X,Y)

A previsão pode ser feita com a ajuda do seguinte código Python -

prediction = clf.predict([[133,37]])
print(prediction)

Podemos visualizar a árvore de decisão com a ajuda do seguinte código Python -

dot_data = tree.export_graphviz(clf,feature_names = data_feature_names,
            out_file = None,filled = True,rounded = True)
graph = pydotplus.graph_from_dot_data(dot_data)
colors = ('orange', 'yellow')
edges = collections.defaultdict(list)

for edge in graph.get_edge_list():
edges[edge.get_source()].append(int(edge.get_destination()))

for edge in edges: edges[edge].sort()

for i in range(2):dest = graph.get_node(str(edges[edge][i]))[0]
dest.set_fillcolor(colors[i])
graph.write_png('Decisiontree16.png')

Ele dará a previsão para o código acima como [‘Woman’] e criar a seguinte árvore de decisão -

Podemos alterar os valores dos recursos na previsão para testá-lo.

Classificador Random Forest

Como sabemos, os métodos de ensemble são os métodos que combinam modelos de aprendizado de máquina em um modelo de aprendizado de máquina mais poderoso. Random Forest, uma coleção de árvores de decisão, é uma delas. É melhor do que uma árvore de decisão única porque, embora retenha os poderes preditivos, pode reduzir o sobreajuste ao calcular a média dos resultados. Aqui, vamos implementar o modelo de floresta aleatório no conjunto de dados de câncer scikit learn.

Importe os pacotes necessários -

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
import matplotlib.pyplot as plt
import numpy as np

Agora, precisamos fornecer o conjunto de dados, o que pode ser feito da seguinte maneira e menos

cancer = load_breast_cancer()
X_train, X_test, y_train,
y_test = train_test_split(cancer.data, cancer.target, random_state = 0)

Depois de fornecer o conjunto de dados, precisamos ajustar o modelo, o que pode ser feito da seguinte maneira -

forest = RandomForestClassifier(n_estimators = 50, random_state = 0)
forest.fit(X_train,y_train)

Agora, obtenha a precisão do subconjunto de treinamento e de teste: se aumentarmos o número de estimadores, a precisão do subconjunto de teste também aumentará.

print('Accuracy on the training subset:(:.3f)',format(forest.score(X_train,y_train)))
print('Accuracy on the training subset:(:.3f)',format(forest.score(X_test,y_test)))

Resultado

Accuracy on the training subset:(:.3f) 1.0
Accuracy on the training subset:(:.3f) 0.965034965034965

Agora, como a árvore de decisão, a floresta aleatória tem o feature_importancemódulo que fornecerá uma visão melhor do peso do recurso do que a árvore de decisão. Pode ser plotado e visualizado da seguinte forma -

n_features = cancer.data.shape[1]
plt.barh(range(n_features),forest.feature_importances_, align='center')
plt.yticks(np.arange(n_features),cancer.feature_names)
plt.xlabel('Feature Importance')
plt.ylabel('Feature')
plt.show()

Desempenho de um classificador

Depois de implementar um algoritmo de aprendizado de máquina, precisamos descobrir a eficácia do modelo. Os critérios para medir a eficácia podem ser baseados em conjuntos de dados e métricas. Para avaliar diferentes algoritmos de aprendizado de máquina, podemos usar diferentes métricas de desempenho. Por exemplo, suponha que se um classificador é usado para distinguir entre imagens de objetos diferentes, podemos usar as métricas de desempenho de classificação, como precisão média, AUC, etc. muito importante porque a escolha das métricas influencia como o desempenho de um algoritmo de aprendizado de máquina é medido e comparado. A seguir estão algumas das métricas -

Matriz de confusão

Basicamente, é usado para problemas de classificação onde a saída pode ser de dois ou mais tipos de classes. É a maneira mais fácil de medir o desempenho de um classificador. Uma matriz de confusão é basicamente uma tabela com duas dimensões, a saber, “Real” e “Previsto”. Ambas as dimensões têm “Verdadeiros positivos (TP)”, “Verdadeiros negativos (TN)”, “Falsos positivos (FP)”, “Falsos negativos (FN)”.

Na matriz de confusão acima, 1 é para classe positiva e 0 é para classe negativa.

A seguir estão os termos associados à matriz de confusão -

True Positives − TPs são os casos em que a classe real do ponto de dados era 1 e o previsto também é 1.
True Negatives − TNs são os casos em que a classe real do ponto de dados era 0 e o previsto também é 0.
False Positives − FPs são os casos em que a classe real do ponto de dados era 0 e o previsto também é 1.
False Negatives − FNs são os casos em que a classe real do ponto de dados era 1 e o previsto também é 0.

Precisão

A matriz de confusão em si não é uma medida de desempenho como tal, mas quase todas as matrizes de desempenho são baseadas na matriz de confusão. Um deles é a precisão. Em problemas de classificação, pode ser definido como o número de previsões corretas feitas pelo modelo sobre todos os tipos de previsões feitas. A fórmula para calcular a precisão é a seguinte -

$$ Precisão = \ frac {TP + TN} {TP + FP + FN + TN} $$

Precisão

É usado principalmente na recuperação de documentos. Pode ser definido como quantos dos documentos devolvidos estão corretos. A seguir está a fórmula para calcular a precisão -

$$ Precisão = \ frac {TP} {TP + FP} $$

Rechamada ou Sensibilidade

Pode ser definido como quantos pontos positivos o modelo retorna. A seguir está a fórmula para calcular o recall / sensibilidade do modelo -

$$ Rechamada = \ frac {TP} {TP + FN} $$

Especificidade

Pode ser definido como quantos negativos o modelo retorna. É exatamente o oposto de lembrar. A seguir está a fórmula para calcular a especificidade do modelo -

$$ Especificidade = \ frac {TN} {TN + FP} $$

Problema de desequilíbrio de classe

O desequilíbrio de classe é o cenário em que o número de observações pertencentes a uma classe é significativamente menor do que as pertencentes às outras classes. Por exemplo, este problema é proeminente no cenário em que precisamos identificar as doenças raras, transações fraudulentas em bancos etc.

Exemplo de classes desequilibradas

Vamos considerar um exemplo de conjunto de dados de detecção de fraude para entender o conceito de classe desequilibrada -

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

Solução

Balancing the classes’atua como uma solução para classes desequilibradas. O objetivo principal de equilibrar as classes é aumentar a frequência da classe minoritária ou diminuir a frequência da classe majoritária. A seguir estão as abordagens para resolver o problema das classes de desequilíbrios -

Re-amostragem

A reamostragem é uma série de métodos usados para reconstruir os conjuntos de dados de amostra - conjuntos de treinamento e conjuntos de teste. A reamostragem é feita para melhorar a precisão do modelo. A seguir estão algumas técnicas de reamostragem -

Random Under-Sampling- Esta técnica visa equilibrar a distribuição de classes, eliminando aleatoriamente exemplos de classes majoritárias. Isso é feito até que as instâncias de classe majoritária e minoritária sejam equilibradas.

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

Neste caso, estamos pegando 10% das amostras sem substituição de instâncias não-fraude e, em seguida, combinamos com as instâncias de fraude -

Observações não fraudulentas após amostragem aleatória = 10% de 4950 = 495

Total de observações após combiná-las com observações fraudulentas = 50 + 495 = 545

Portanto, agora, a taxa de eventos para o novo conjunto de dados após sob amostragem = 9%

A principal vantagem dessa técnica é que ela pode reduzir o tempo de execução e melhorar o armazenamento. Mas, por outro lado, ele pode descartar informações úteis enquanto reduz o número de amostras de dados de treinamento.

Random Over-Sampling - Esta técnica visa equilibrar a distribuição de classes, aumentando o número de instâncias na classe minoritária, replicando-as.

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

No caso de estarmos replicando 50 observações fraudulentas 30 vezes, as observações fraudulentas após replicar as observações da classe minoritária seriam 1500. E então o total de observações nos novos dados após a sobreamostragem seria 4950 + 1500 = 6450. Portanto, a taxa de eventos para o novo conjunto de dados seria 1500/6450 = 23%.

A principal vantagem desse método é que não haveria perda de informações úteis. Mas, por outro lado, tem maiores chances de sobreajuste porque replica os eventos da classe minoritária.

Técnicas de conjunto

Esta metodologia é usada basicamente para modificar algoritmos de classificação existentes para torná-los adequados para conjuntos de dados desequilibrados. Nesta abordagem, construímos vários classificadores de dois estágios a partir dos dados originais e, em seguida, agregamos suas previsões. O classificador de floresta aleatório é um exemplo de classificador baseado em conjunto.

↰ Previous page Next page ↱