Classificação - Introdução

Introdução à Classificação

A classificação pode ser definida como o processo de predizer classe ou categoria a partir de valores observados ou dados dados. A saída categorizada pode ter a forma “Preto” ou “Branco” ou “spam” ou “sem spam”.

Matematicamente, a classificação é a tarefa de aproximar uma função de mapeamento (f) das variáveis de entrada (X) às variáveis de saída (Y). Ele basicamente pertence ao aprendizado de máquina supervisionado, no qual os alvos também são fornecidos junto com o conjunto de dados de entrada.

Um exemplo de problema de classificação pode ser a detecção de spam em emails. Pode haver apenas duas categorias de saída, “spam” e “sem spam”; portanto, esta é uma classificação de tipo binário.

Para implementar essa classificação, primeiro precisamos treinar o classificador. Para este exemplo, os emails “spam” e “sem spam” seriam usados como dados de treinamento. Depois de treinar com sucesso o classificador, ele pode ser usado para detectar um e-mail desconhecido.

Tipos de alunos na classificação

Temos dois tipos de alunos em relação aos problemas de classificação -

Aprendizes Preguiçosos

Como o nome sugere, esse tipo de aluno espera que os dados de teste apareçam depois de armazenar os dados de treinamento. A classificação é feita somente após obter os dados de teste. Eles gastam menos tempo treinando, mas mais tempo prevendo. Exemplos de alunos preguiçosos são K-vizinho mais próximo e raciocínio baseado em casos.

Alunos ansiosos

Ao contrário dos alunos preguiçosos, os alunos ansiosos constroem um modelo de classificação sem esperar que os dados de teste apareçam após o armazenamento dos dados de treinamento. Eles passam mais tempo treinando, mas menos tempo fazendo previsões. Exemplos de alunos ansiosos são Árvores de Decisão, Naïve Bayes e Redes Neurais Artificiais (RNA).

Construindo um classificador em Python

Scikit-learn, uma biblioteca Python para aprendizado de máquina, pode ser usada para construir um classificador em Python. As etapas para construir um classificador em Python são as seguintes -

Etapa 1: importando o pacote python necessário

Para construir um classificador usando o scikit-learn, precisamos importá-lo. Podemos importá-lo usando o seguinte script -

import sklearn

Etapa 2: Importar conjunto de dados

Depois de importar o pacote necessário, precisamos de um conjunto de dados para construir o modelo de previsão de classificação. Podemos importá-lo do conjunto de dados sklearn ou usar outro de acordo com nossa necessidade. Vamos usar o Breast Cancer Wisconsin Diagnostic Database da sklearn. Podemos importá-lo com a ajuda do seguinte script -

from sklearn.datasets import load_breast_cancer

O script a seguir carregará o conjunto de dados;

data = load_breast_cancer()

Também precisamos organizar os dados e isso pode ser feito com a ajuda dos seguintes scripts -

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

O seguinte comando irá imprimir o nome das etiquetas, 'malignant'e'benign'no caso de nosso banco de dados.

print(label_names)

A saída do comando acima são os nomes dos rótulos -

['malignant' 'benign']

Esses rótulos são mapeados para valores binários 0 e 1. Malignant câncer é representado por 0 e Benign câncer é representado por 1.

Os nomes e valores dos recursos desses rótulos podem ser vistos com a ajuda dos seguintes comandos -

print(feature_names[0])

A saída do comando acima são os nomes dos recursos para rótulo 0, ou seja Malignant câncer -

mean radius

Da mesma forma, os nomes dos recursos para etiqueta podem ser produzidos da seguinte forma -

print(feature_names[1])

A saída do comando acima são os nomes dos recursos para o rótulo 1, ou seja, Benign câncer -

mean texture

Podemos imprimir os recursos para essas etiquetas com a ajuda do seguinte comando -

print(features[0])

Isso dará a seguinte saída -

[
   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
]

Podemos imprimir os recursos para essas etiquetas com a ajuda do seguinte comando -

print(features[1])

Isso dará a seguinte saída -

[
   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
]

Etapa 3: Organização de dados em conjuntos de treinamento e teste

Como precisamos testar nosso modelo em dados não vistos, dividiremos nosso conjunto de dados em duas partes: um conjunto de treinamento e um conjunto de teste. Podemos usar a função train_test_split () do pacote sklearn python para dividir os dados em conjuntos. O seguinte comando importará a função -

from sklearn.model_selection import train_test_split

Agora, o próximo comando dividirá os dados em dados de treinamento e teste. Neste exemplo, estamos usando 40 por cento dos dados para fins de teste e 60 por cento dos dados para fins de treinamento -

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

Passo 4: Avaliação do modelo

Depois de dividir os dados em treinamento e teste, precisamos construir o modelo. Estaremos usando o algoritmo Naïve Bayes para este propósito. Os seguintes comandos irão importar o módulo GaussianNB -

from sklearn.naive_bayes import GaussianNB

Agora, inicialize o modelo da seguinte maneira -

gnb = GaussianNB()

Em seguida, com a ajuda do seguinte comando, podemos treinar o modelo -

model = gnb.fit(train, train_labels)

Agora, para fins de avaliação, precisamos fazer previsões. Isso pode ser feito usando a função predict () da seguinte maneira -

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

Isso dará a seguinte saída -

[
   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 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

]

A série acima de 0s e 1s na saída são os valores previstos para o Malignant e Benign classes de tumor.

Etapa 5: Encontrar a precisão

Podemos encontrar a precisão da construção do modelo na etapa anterior, comparando as duas matrizes, ou seja, test_labels e preds. Estaremos usando a função precision_score () para determinar a precisão.

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

A saída acima mostra que o classificador NaïveBayes é 95,17% preciso.

Métricas de avaliação de classificação

O trabalho não está concluído, mesmo que você tenha concluído a implementação de seu aplicativo ou modelo de aprendizado de máquina. Devemos ter que descobrir o quão eficaz é o nosso modelo? Pode haver diferentes métricas de avaliação, mas devemos escolhê-las com cuidado 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 importantes métricas de avaliação de classificação entre as quais você pode escolher com base em seu conjunto de dados e tipo de problema -

Matriz de confusão

É a maneira mais fácil de medir o desempenho de um problema de classificação em que a saída pode ser de dois ou mais tipos de classes. Uma matriz de confusão nada mais é do que uma mesa com duas dimensões viz. "Real" e "Previsto" e, além disso, ambas as dimensões têm "Verdadeiros positivos (TP)", "Verdadeiros negativos (TN)", "Falsos positivos (FP)", "Falsos negativos (FN)" conforme mostrado abaixo -

A explicação dos termos associados à matriz de confusão é a seguinte -

True Positives (TP) - É o caso quando a classe real e a classe prevista do ponto de dados são 1.
True Negatives (TN) - É o caso quando a classe real e a classe prevista do ponto de dados são 0.
False Positives (FP) - É o caso quando a classe real do ponto de dados é 0 e a classe prevista do ponto de dados é 1.
False Negatives (FN) - É o caso quando a classe real do ponto de dados é 1 e a classe prevista do ponto de dados é 0.

Podemos encontrar a matriz de confusão com a ajuda da função confused_matrix () de sklearn. Com a ajuda do seguinte script, podemos encontrar a matriz de confusão do classificador binário construído acima -

from sklearn.metrics import confusion_matrix

Resultado

[
   [ 73   7]
   [  4 144]
]

Precisão

Pode ser definido como o número de previsões corretas feitas por nosso modelo de ML. Podemos calculá-lo facilmente pela matriz de confusão com a ajuda da seguinte fórmula -

$$ = \ frac {+} {+++} $$

Para o classificador binário construído acima, TP + TN = 73 + 144 = 217 e TP + FP + FN + TN = 73 + 7 + 4 + 144 = 228.

Portanto, Precisão = 217/228 = 0,951754385965, que é o mesmo que calculamos após criar nosso classificador binário.

Precisão

A precisão, usada na recuperação de documentos, pode ser definida como o número de documentos corretos retornados por nosso modelo de ML. Podemos calculá-lo facilmente pela matriz de confusão com a ajuda da seguinte fórmula -

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

Para o classificador binário construído acima, TP = 73 e TP + FP = 73 + 7 = 80.

Portanto, Precisão = 73/80 = 0,915

Rechamada ou Sensibilidade

A recuperação pode ser definida como o número de positivos retornados por nosso modelo de ML. Podemos calculá-lo facilmente pela matriz de confusão com a ajuda da seguinte fórmula -

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

Para o classificador binário construído acima, TP = 73 e TP + FN = 73 + 4 = 77.

Portanto, Precisão = 73/77 = 0,94805

Especificidade

A especificidade, em contraste com a recordação, pode ser definida como o número de negativos retornados por nosso modelo de ML. Podemos calculá-lo facilmente pela matriz de confusão com a ajuda da seguinte fórmula -

$$ = \ frac {N} {N + FP} $$

Para o classificador binário construído acima, TN = 144 e TN + FP = 144 + 7 = 151.

Portanto, Precisão = 144/151 = 0,95364