Classificazione - Introduzione

Introduzione alla classificazione

La classificazione può essere definita come il processo di previsione della classe o della categoria dai valori osservati o dai punti dati forniti. L'output classificato può avere il formato "Nero" o "Bianco", "spam" o "no spam".

Matematicamente, la classificazione è il compito di approssimare una funzione di mappatura (f) da variabili di input (X) a variabili di output (Y). Fondamentalmente appartiene all'apprendimento automatico supervisionato in cui vengono forniti anche gli obiettivi insieme al set di dati di input.

Un esempio di problema di classificazione può essere il rilevamento dello spam nelle e-mail. Possono esserci solo due categorie di output, "spam" e "no spam"; quindi questa è una classificazione di tipo binario.

Per implementare questa classificazione, dobbiamo prima addestrare il classificatore. In questo esempio, i messaggi di posta elettronica "spam" e "no spam" verranno utilizzati come dati di addestramento. Dopo aver addestrato con successo il classificatore, può essere utilizzato per rilevare un'e-mail sconosciuta.

Tipi di discenti nella classificazione

Abbiamo due tipi di discenti in relazione ai problemi di classificazione:

Studenti pigri

Come suggerisce il nome, questo tipo di discenti attende che i dati di test vengano visualizzati dopo aver memorizzato i dati di formazione. La classificazione viene eseguita solo dopo aver ottenuto i dati del test. Dedicano meno tempo all'addestramento ma più tempo alla previsione. Esempi di studenti pigri sono il vicino più prossimo K e il ragionamento basato sui casi.

Studenti desiderosi

Al contrario degli studenti pigri, gli studenti desiderosi costruiscono un modello di classificazione senza attendere che i dati di test vengano visualizzati dopo aver archiviato i dati di formazione. Dedicano più tempo all'addestramento ma meno tempo alla previsione. Esempi di studenti desiderosi sono gli alberi decisionali, i Naïve Bayes e le reti neurali artificiali (ANN).

Costruire un classificatore in Python

Scikit-learn, una libreria Python per l'apprendimento automatico può essere utilizzata per creare un classificatore in Python. I passaggi per la creazione di un classificatore in Python sono i seguenti:

Passaggio 1: importazione del pacchetto Python necessario

Per creare un classificatore utilizzando scikit-learn, dobbiamo importarlo. Possiamo importarlo usando il seguente script:

import sklearn

Passaggio 2: importazione del set di dati

Dopo aver importato il pacchetto necessario, è necessario un set di dati per creare un modello di previsione della classificazione. Possiamo importarlo dal set di dati sklearn o utilizzarne un altro secondo le nostre esigenze. Utilizzeremo il database diagnostico del cancro al seno di sklearn Wisconsin. Possiamo importarlo con l'aiuto del seguente script:

from sklearn.datasets import load_breast_cancer

Il seguente script caricherà il set di dati;

data = load_breast_cancer()

Abbiamo anche bisogno di organizzare i dati e può essere fatto con l'aiuto dei seguenti script:

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

Il seguente comando stamperà il nome delle etichette, "malignant' e 'benign'nel caso del nostro database.

print(label_names)

L'output del comando precedente sono i nomi delle etichette -

['malignant' 'benign']

Queste etichette sono mappate ai valori binari 0 e 1. Malignant il cancro è rappresentato da 0 e Benign il cancro è rappresentato da 1.

I nomi delle caratteristiche e i valori delle caratteristiche di queste etichette possono essere visualizzati con l'aiuto dei seguenti comandi:

print(feature_names[0])

L'output del comando precedente sono i nomi delle funzionalità per l'etichetta 0, ad es Malignant cancro -

mean radius

Allo stesso modo, i nomi delle caratteristiche per l'etichetta possono essere prodotti come segue:

print(feature_names[1])

L'output del comando precedente sono i nomi delle funzionalità per l'etichetta 1, ad es Benign cancro -

mean texture

Possiamo stampare le caratteristiche per queste etichette con l'aiuto del seguente comando:

print(features[0])

Questo darà il seguente output:

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

Possiamo stampare le caratteristiche per queste etichette con l'aiuto del seguente comando:

print(features[1])

Questo darà il seguente output:

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

Passaggio 3: organizzazione dei dati in set di addestramento e test

Poiché dobbiamo testare il nostro modello su dati invisibili, divideremo il nostro set di dati in due parti: un set di addestramento e un set di test. Possiamo usare la funzione train_test_split () del pacchetto sklearn python per dividere i dati in set. Il seguente comando importerà la funzione:

from sklearn.model_selection import train_test_split

Ora, il prossimo comando suddividerà i dati in dati di addestramento e test. In questo esempio, utilizziamo il 40% dei dati a scopo di test e il 60% dei dati a scopo di formazione -

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

Step4: valutazione del modello

Dopo aver diviso i dati in addestramento e test, è necessario creare il modello. A tale scopo utilizzeremo l'algoritmo Naïve Bayes. I seguenti comandi importeranno il modulo GaussianNB -

from sklearn.naive_bayes import GaussianNB

Ora inizializza il modello come segue:

gnb = GaussianNB()

Successivamente, con l'aiuto del seguente comando possiamo addestrare il modello:

model = gnb.fit(train, train_labels)

Ora, a scopo di valutazione, dobbiamo fare previsioni. Può essere fatto utilizzando la funzione prediction () come segue:

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

Questo darà il seguente output:

[
   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

]

Le precedenti serie di 0 e 1 in output sono i valori previsti per Malignant e Benign classi di tumori.

Passaggio 5: trovare la precisione

Possiamo trovare l'accuratezza della costruzione del modello nel passaggio precedente confrontando i due array, ovvero test_labels e preds. Useremo la funzione accuratezza_score () per determinare l'accuratezza.

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

L'output sopra mostra che il classificatore NaïveBayes è accurato al 95,17%.

Metriche di valutazione della classificazione

Il lavoro non viene completato anche se è stata completata l'implementazione dell'applicazione o del modello di Machine Learning. Dobbiamo scoprire quanto è efficace il nostro modello? Possono esserci metriche di valutazione diverse, ma dobbiamo sceglierle con attenzione perché la scelta delle metriche influenza il modo in cui vengono misurate e confrontate le prestazioni di un algoritmo di apprendimento automatico.

Di seguito sono riportate alcune importanti metriche di valutazione della classificazione tra le quali è possibile scegliere in base al set di dati e al tipo di problema:

Matrice di confusione

È il modo più semplice per misurare le prestazioni di un problema di classificazione in cui l'output può essere di due o più tipi di classi. Una matrice di confusione non è altro che una tabella con due dimensioni. "Actual" e "Predicted" e inoltre, entrambe le dimensioni hanno "True Positives (TP)", "True Negatives (TN)", "False Positives (FP)", "False Negatives (FN)" come mostrato di seguito -

La spiegazione dei termini associati alla matrice di confusione è la seguente:

True Positives (TP) - È il caso in cui sia la classe effettiva che la classe prevista del punto dati sono 1.
True Negatives (TN) - È il caso in cui sia la classe effettiva che la classe prevista del punto dati sono 0.
False Positives (FP) - È il caso in cui la classe effettiva del punto dati è 0 e la classe prevista del punto dati è 1.
False Negatives (FN) - È il caso in cui la classe effettiva del punto dati è 1 e la classe prevista del punto dati è 0.

Possiamo trovare la matrice di confusione con l'aiuto della funzione confusion_matrix () di sklearn. Con l'aiuto del seguente script, possiamo trovare la matrice di confusione del classificatore binario costruito sopra -

from sklearn.metrics import confusion_matrix

Produzione

[
   [ 73   7]
   [  4 144]
]

Precisione

Può essere definito come il numero di previsioni corrette fatte dal nostro modello ML. Possiamo facilmente calcolarlo dalla matrice di confusione con l'aiuto della seguente formula:

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

Per il classificatore binario costruito sopra, TP + TN = 73 + 144 = 217 e TP + FP + FN + TN = 73 + 7 + 4 + 144 = 228.

Quindi, Precisione = 217/228 = 0,951754385965 che è lo stesso che abbiamo calcolato dopo aver creato il nostro classificatore binario.

Precisione

La precisione, utilizzata nel recupero dei documenti, può essere definita come il numero di documenti corretti restituiti dal nostro modello ML. Possiamo facilmente calcolarlo dalla matrice di confusione con l'aiuto della seguente formula:

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

Per il classificatore binario costruito sopra, TP = 73 e TP + FP = 73 + 7 = 80.

Quindi, Precisione = 73/80 = 0,915

Richiamo o sensibilità

Il richiamo può essere definito come il numero di positivi restituiti dal nostro modello ML. Possiamo facilmente calcolarlo dalla matrice di confusione con l'aiuto della seguente formula:

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

Per il classificatore binario costruito sopra, TP = 73 e TP + FN = 73 + 4 = 77.

Quindi, Precisione = 73/77 = 0,94805

Specificità

La specificità, a differenza del richiamo, può essere definita come il numero di negativi restituiti dal nostro modello ML. Possiamo facilmente calcolarlo dalla matrice di confusione con l'aiuto della seguente formula:

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

Per il classificatore binario costruito sopra, TN = 144 e TN + FP = 144 + 7 = 151.

Quindi, Precisione = 144/151 = 0,95364