AI con Python - Apprendimento supervisionato: classificazione
In questo capitolo, ci concentreremo sull'implementazione dell'apprendimento supervisionato - classificazione.
La tecnica o il modello di classificazione tenta di trarre conclusioni dai valori osservati. Nel problema di classificazione, abbiamo l'output classificato come "Nero" o "bianco" o "Insegnamento" e "Non insegnamento". Durante la creazione del modello di classificazione, è necessario disporre di un set di dati di addestramento che contenga punti dati e le etichette corrispondenti. Ad esempio, se vogliamo verificare se l'immagine è di un'auto o meno. Per verificarlo, creeremo un set di dati di addestramento con le due classi relative a "macchina" e "senza macchina". Quindi dobbiamo addestrare il modello utilizzando i campioni di addestramento. I modelli di classificazione vengono utilizzati principalmente nel riconoscimento facciale, nell'identificazione dello spam, ecc.
Passaggi per la creazione di un classificatore in Python
Per creare un classificatore in Python, utilizzeremo Python 3 e Scikit-learn, uno strumento per l'apprendimento automatico. Segui questi passaggi per creare un classificatore in Python:
Passaggio 1: importare Scikit-learn
Questo sarebbe il primo passo per costruire un classificatore in Python. In questo passaggio, installeremo un pacchetto Python chiamato Scikit-learn che è uno dei migliori moduli di apprendimento automatico in Python. Il seguente comando ci aiuterà a importare il pacchetto:
Import SklearnPassaggio 2: importare il set di dati di Scikit-learn
In questo passaggio, possiamo iniziare a lavorare con il set di dati per il nostro modello di machine learning. Qui useremothe Database diagnostico del cancro al seno del Wisconsin. Il set di dati include varie informazioni sui tumori del cancro al seno, nonché etichette di classificazione dimalignant o benign. Il set di dati contiene 569 istanze, o dati, su 569 tumori e include informazioni su 30 attributi o caratteristiche, come il raggio del tumore, la consistenza, la levigatezza e l'area. Con l'aiuto del seguente comando, possiamo importare il set di dati sul cancro al seno di Scikit-learn -
from sklearn.datasets import load_breast_cancerOra, il seguente comando caricherà il set di dati.
data = load_breast_cancer()Di seguito è riportato un elenco di importanti chiavi del dizionario:
- Nomi delle etichette di classificazione (target_names)
- Le etichette effettive (target)
- I nomi di attributi / caratteristiche (feature_names)
- L'attributo (dati)
Ora, con l'aiuto del seguente comando, possiamo creare nuove variabili per ogni importante insieme di informazioni e assegnare i dati. In altre parole, possiamo organizzare i dati con i seguenti comandi:
label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']Ora, per renderlo più chiaro, possiamo stampare le etichette delle classi, l'etichetta della prima istanza di dati, i nomi delle nostre caratteristiche e il valore della caratteristica con l'aiuto dei seguenti comandi:
print(label_names)Il comando precedente stamperà i nomi delle classi che sono rispettivamente maligni e benigni. Viene mostrato come output di seguito:
['malignant' 'benign']Ora, il comando seguente mostrerà che sono mappati ai valori binari 0 e 1. Qui 0 rappresenta il cancro maligno e 1 rappresenta il cancro benigno. Riceverai il seguente output:
print(labels[0])
0I due comandi forniti di seguito produrranno i nomi e i valori delle caratteristiche.
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]Dall'output di cui sopra, possiamo vedere che la prima istanza di dati è un tumore maligno il cui raggio è 1.7990000e + 01.
Passaggio 3: organizzazione dei dati in set
In questa fase, divideremo i nostri dati in due parti, vale a dire un set di addestramento e un set di test. La divisione dei dati in questi set è molto importante perché dobbiamo testare il nostro modello sui dati invisibili. Per dividere i dati in insiemi, sklearn ha una funzione chiamatatrain_test_split()funzione. Con l'aiuto dei seguenti comandi, possiamo dividere i dati in questi set:
from sklearn.model_selection import train_test_splitIl comando precedente importerà il file train_test_splitfunzione da sklearn e il comando seguente suddividerà i dati in dati di addestramento e test. Nell'esempio riportato di seguito, stiamo utilizzando il 40% dei dati per il test e i dati rimanenti verranno utilizzati per l'addestramento del modello.
train, test, train_labels, test_labels = train_test_split(features,labels,test_size = 0.40, random_state = 42)Passaggio 4: costruzione del modello
In questa fase, costruiremo il nostro modello. Useremo l'algoritmo Naïve Bayes per costruire il modello. I seguenti comandi possono essere utilizzati per costruire il modello:
from sklearn.naive_bayes import GaussianNBIl comando precedente importerà il modulo GaussianNB. Ora, il seguente comando ti aiuterà a inizializzare il modello.
gnb = GaussianNB()Addestreremo il modello adattandolo ai dati utilizzando gnb.fit ().
model = gnb.fit(train, train_labels)Passaggio 5: valutazione del modello e della sua accuratezza
In questa fase, valuteremo il modello facendo previsioni sui nostri dati di test. Quindi scopriremo anche la sua precisione. Per fare previsioni, useremo la funzione prediction (). Il seguente comando ti aiuterà a farlo:
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]Le precedenti serie di 0 e 1 sono i valori previsti per le classi di tumore: maligno e benigno.
Ora, confrontando i due array, vale a dire test_labels e preds, possiamo scoprire la precisione del nostro modello. Useremo il fileaccuracy_score()funzione per determinare la precisione. Considera il seguente comando per questo:
from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965Il risultato mostra che il classificatore NaïveBayes è accurato al 95,17%.
In questo modo, con l'aiuto dei passaggi precedenti possiamo costruire il nostro classificatore in Python.
Classificatore di edifici in Python
In questa sezione impareremo come costruire un classificatore in Python.
Classificatore Naïve Bayes
Naïve Bayes è una tecnica di classificazione utilizzata per costruire un classificatore utilizzando il teorema di Bayes. Il presupposto è che i predittori siano indipendenti. In parole semplici, si presume che la presenza di una particolare caratteristica in una classe non sia correlata alla presenza di qualsiasi altra caratteristica. Per costruire il classificatore Naïve Bayes dobbiamo usare la libreria python chiamata scikit learn. Ci sono tre tipi di modelli Naïve Bayes denominatiGaussian, Multinomial and Bernoulli sotto scikit impara il pacchetto.
Per creare un modello di classificatore di machine learning Naïve Bayes, abbiamo bisogno dei seguenti & meno
Set di dati
Utilizzeremo il set di dati denominato Breast Cancer Wisconsin Diagnostic Database. Il set di dati include varie informazioni sui tumori del cancro al seno, nonché etichette di classificazione dimalignant o benign. Il set di dati contiene 569 istanze, o dati, su 569 tumori e include informazioni su 30 attributi o caratteristiche, come il raggio del tumore, la consistenza, la levigatezza e l'area. Possiamo importare questo set di dati dal pacchetto sklearn.
Modello Naïve Bayes
Per costruire il classificatore Naïve Bayes, abbiamo bisogno di un modello Naïve Bayes. Come detto in precedenza, ci sono tre tipi di modelli Naïve Bayes denominatiGaussian, Multinomial e Bernoullisotto scikit impara il pacchetto. Qui, nel seguente esempio useremo il modello Gaussian Naïve Bayes.
Utilizzando quanto sopra, costruiremo un modello di apprendimento automatico Naïve Bayes per utilizzare le informazioni sul tumore per prevedere se un tumore è maligno o benigno.
Per cominciare, dobbiamo installare il modulo sklearn. Può essere fatto con l'aiuto del seguente comando:
Import SklearnOra, dobbiamo importare il set di dati denominato Breast Cancer Wisconsin Diagnostic Database.
from sklearn.datasets import load_breast_cancerOra, il seguente comando caricherà il set di dati.
data = load_breast_cancer()I dati possono essere organizzati come segue:
label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']Ora, per renderlo più chiaro, possiamo stampare le etichette delle classi, l'etichetta della prima istanza di dati, i nomi delle nostre caratteristiche e il valore della caratteristica con l'aiuto dei seguenti comandi:
print(label_names)Il comando precedente stamperà i nomi delle classi che sono rispettivamente maligni e benigni. Viene mostrato come output di seguito:
['malignant' 'benign']Ora, il comando fornito di seguito mostrerà che sono mappati ai valori binari 0 e 1. Qui 0 rappresenta il cancro maligno e 1 rappresenta il cancro benigno. Viene mostrato come output di seguito:
print(labels[0])
0I due comandi seguenti produrranno i nomi e i valori delle caratteristiche.
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]Dall'output di cui sopra, possiamo vedere che la prima istanza di dati è un tumore maligno il cui raggio principale è 1.7990000e + 01.
Per testare il nostro modello su dati invisibili, dobbiamo suddividere i nostri dati in dati di addestramento e test. Può essere fatto con l'aiuto del seguente codice:
from sklearn.model_selection import train_test_splitIl comando precedente importerà il file train_test_splitfunzione da sklearn e il comando seguente suddividerà i dati in dati di addestramento e test. Nell'esempio seguente, stiamo usando il 40% dei dati per il test e i dati di remining sarebbero usati per l'addestramento del modello.
train, test, train_labels, test_labels =
train_test_split(features,labels,test_size = 0.40, random_state = 42)Ora stiamo costruendo il modello con i seguenti comandi:
from sklearn.naive_bayes import GaussianNBIl comando precedente importerà il file GaussianNBmodulo. Ora, con il comando fornito di seguito, dobbiamo inizializzare il modello.
gnb = GaussianNB()Addestreremo il modello adattandolo ai dati utilizzando gnb.fit().
model = gnb.fit(train, train_labels)Ora, valuta il modello facendo previsioni sui dati del test e può essere fatto come segue:
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]Le precedenti serie di 0 e 1 sono i valori previsti per le classi tumorali, cioè maligne e benigne.
Ora, confrontando i due array, vale a dire test_labels e preds, possiamo scoprire la precisione del nostro modello. Useremo il fileaccuracy_score()funzione per determinare la precisione. Considera il seguente comando:
from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965Il risultato mostra che il classificatore NaïveBayes è accurato al 95,17%.
Quello era un classificatore di apprendimento automatico basato sul modello gaussiano Naïve Bayse.
Support Vector Machines (SVM)
Fondamentalmente, Support vector machine (SVM) è un algoritmo di apprendimento automatico supervisionato che può essere utilizzato sia per la regressione che per la classificazione. Il concetto principale di SVM è quello di tracciare ciascun elemento di dati come un punto nello spazio n-dimensionale con il valore di ciascuna caratteristica che è il valore di una particolare coordinata. Qui n sarebbero le caratteristiche che avremmo. Di seguito è riportata una semplice rappresentazione grafica per comprendere il concetto di SVM -
Nel diagramma sopra, abbiamo due caratteristiche. Quindi, dobbiamo prima tracciare queste due variabili in uno spazio bidimensionale in cui ogni punto ha due coordinate, chiamate vettori di supporto. La linea divide i dati in due diversi gruppi classificati. Questa linea sarebbe il classificatore.
Qui costruiremo un classificatore SVM usando scikit-learn e il set di dati iris. La libreria Scikitlearn ha l'estensionesklearn.svmmodule e fornisce sklearn.svm.svc per la classificazione. Di seguito è mostrato il classificatore SVM per prevedere la classe della pianta di iris in base a 4 caratteristiche.
Set di dati
Useremo il set di dati iris che contiene 3 classi di 50 istanze ciascuna, in cui ogni classe si riferisce a un tipo di pianta di iris. Ogni istanza ha le quattro caratteristiche: lunghezza del sepalo, larghezza del sepalo, lunghezza del petalo e larghezza del petalo. Di seguito è mostrato il classificatore SVM per prevedere la classe della pianta di iris in base a 4 caratteristiche.
Kernel
È una tecnica utilizzata da SVM. Fondamentalmente queste sono le funzioni che prendono lo spazio di input a bassa dimensione e lo trasformano in uno spazio di dimensione superiore. Converte un problema non separabile in un problema separabile. La funzione kernel può essere una qualsiasi tra lineare, polinomiale, rbf e sigmoide. In questo esempio, useremo il kernel lineare.
Ora importiamo i seguenti pacchetti:
import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as pltOra, carica i dati di input -
iris = datasets.load_iris()Stiamo prendendo le prime due funzionalità:
X = iris.data[:, :2]
y = iris.targetTracciamo i confini della macchina vettoriale di supporto con i dati originali. Stiamo creando una mesh da tracciare.
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()]Dobbiamo dare il valore del parametro di regolarizzazione.
C = 1.0Dobbiamo creare l'oggetto classificatore 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')
Regressione logistica
Fondamentalmente, il modello di regressione logistica è uno dei membri della famiglia di algoritmi di classificazione supervisionati. La regressione logistica misura la relazione tra variabili dipendenti e variabili indipendenti stimando le probabilità utilizzando una funzione logistica.
Qui, se parliamo di variabili dipendenti e indipendenti, la variabile dipendente è la variabile della classe di destinazione che andremo a prevedere e dall'altra parte le variabili indipendenti sono le caratteristiche che useremo per prevedere la classe di destinazione.
Nella regressione logistica, stimare le probabilità significa prevedere la probabilità che si verifichi l'evento. Ad esempio, il proprietario del negozio vorrebbe prevedere che il cliente che è entrato nel negozio acquisterà la play station (ad esempio) o meno. Ci sarebbero molte caratteristiche del cliente - sesso, età, ecc. Che sarebbero osservate dal negoziante per prevedere la probabilità che si verifichi, ovvero acquistare o meno una play station. La funzione logistica è la curva sigmoidea che viene utilizzata per costruire la funzione con vari parametri.
Prerequisiti
Prima di costruire il classificatore utilizzando la regressione logistica, dobbiamo installare il pacchetto Tkinter sul nostro sistema. Può essere installato dahttps://docs.python.org/2/library/tkinter.html.
Ora, con l'aiuto del codice fornito di seguito, possiamo creare un classificatore utilizzando la regressione logistica -
Innanzitutto, importeremo alcuni pacchetti:
import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as pltOra, dobbiamo definire i dati di esempio che possono essere eseguiti come segue:
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])Successivamente, dobbiamo creare il classificatore di regressione logistica, che può essere fatto come segue:
Classifier_LR = linear_model.LogisticRegression(solver = 'liblinear', C = 75)Ultimo ma non meno importante, dobbiamo addestrare questo classificatore -
Classifier_LR.fit(X, y)Ora, come possiamo visualizzare l'output? Può essere fatto creando una funzione chiamata 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.0Nella riga sopra, abbiamo definito i valori minimo e massimo X e Y da utilizzare nella griglia mesh. Inoltre, definiremo la dimensione del passo per tracciare la griglia mesh.
mesh_step_size = 0.02Definiamo la griglia mesh dei valori X e Y come segue:
x_vals, y_vals = np.meshgrid(np.arange(min_x, max_x, mesh_step_size),
np.arange(min_y, max_y, mesh_step_size))Con l'aiuto del seguente codice, possiamo eseguire il classificatore sulla griglia mesh:
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)La seguente riga di codice specificherà i confini della trama
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()Ora, dopo aver eseguito il codice, otterremo il seguente output, classificatore di regressione logistica:
Classificatore dell'albero decisionale
Un albero decisionale è fondamentalmente un diagramma di flusso ad albero binario in cui ogni nodo divide un gruppo di osservazioni in base a qualche variabile caratteristica.
Qui stiamo costruendo un classificatore dell'albero decisionale per prevedere uomini o donne. Prenderemo un set di dati molto piccolo con 19 campioni. Questi campioni consisterebbero di due caratteristiche: "altezza" e "lunghezza dei capelli".
Prerequisito
Per creare il seguente classificatore, è necessario installare pydotplus e graphviz. Fondamentalmente, graphviz è uno strumento per disegnare grafici utilizzando file punto epydotplusè un modulo del linguaggio Dot di Graphviz. Può essere installato con il gestore di pacchetti o pip.
Ora possiamo costruire il classificatore dell'albero decisionale con l'aiuto del seguente codice Python:
Per cominciare, importiamo alcune importanti librerie come segue:
import pydotplus
from sklearn import tree
from sklearn.datasets import load_iris
from sklearn.metrics import classification_report
from sklearn import cross_validation
import collectionsOra, dobbiamo fornire il set di dati come segue:
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)Dopo aver fornito il set di dati, dobbiamo adattare il modello che può essere fatto come segue:
clf = tree.DecisionTreeClassifier()
clf = clf.fit(X,Y)La previsione può essere fatta con l'aiuto del seguente codice Python:
prediction = clf.predict([[133,37]])
print(prediction)Possiamo visualizzare l'albero decisionale con l'aiuto del seguente codice 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')Fornirà la previsione per il codice sopra come [‘Woman’] e crea il seguente albero decisionale:
Possiamo modificare i valori delle caratteristiche nella previsione per testarla.
Classificatore casuale della foresta
Come sappiamo, i metodi di insieme sono i metodi che combinano i modelli di apprendimento automatico in un modello di apprendimento automatico più potente. Random Forest, una raccolta di alberi decisionali, è uno di questi. È migliore del singolo albero decisionale perché, pur mantenendo i poteri predittivi, può ridurre l'over-fitting calcolando la media dei risultati. Qui, implementeremo il modello di foresta casuale su scikit learn cancer dataset.
Importa i pacchetti necessari -
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 npOra, dobbiamo fornire il set di dati che può essere fatto come segue e meno
cancer = load_breast_cancer()
X_train, X_test, y_train,
y_test = train_test_split(cancer.data, cancer.target, random_state = 0)Dopo aver fornito il set di dati, dobbiamo adattare il modello che può essere fatto come segue:
forest = RandomForestClassifier(n_estimators = 50, random_state = 0)
forest.fit(X_train,y_train)Ora, ottieni l'accuratezza sull'addestramento e sul sottoinsieme di test: se aumentiamo il numero di stimatori, aumenterebbe anche l'accuratezza del sottoinsieme di test.
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)))Produzione
Accuracy on the training subset:(:.3f) 1.0
Accuracy on the training subset:(:.3f) 0.965034965034965Ora, come l'albero decisionale, la foresta casuale ha l'estensione feature_importancemodulo che fornirà una visione migliore del peso della caratteristica rispetto all'albero decisionale. Può essere tracciato e visualizzato come segue:
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()
Prestazioni di un classificatore
Dopo aver implementato un algoritmo di apprendimento automatico, dobbiamo scoprire quanto sia efficace il modello. I criteri per misurare l'efficacia possono essere basati su set di dati e metriche. Per valutare diversi algoritmi di apprendimento automatico, possiamo utilizzare diverse metriche delle prestazioni. Ad esempio, supponiamo che se un classificatore viene utilizzato per distinguere tra immagini di oggetti diversi, possiamo utilizzare le metriche delle prestazioni di classificazione come precisione media, AUC, ecc. In un senso o nell'altro, la metrica che scegliamo per valutare il nostro modello di apprendimento automatico è molto importante perché la scelta delle metriche influenza il modo in cui vengono misurate e confrontate le prestazioni di un algoritmo di machine learning. Di seguito sono riportate alcune delle metriche:
Matrice di confusione
Fondamentalmente viene utilizzato per problemi di classificazione in cui l'output può essere di due o più tipi di classi. È il modo più semplice per misurare le prestazioni di un classificatore. Una matrice di confusione è fondamentalmente una tabella con due dimensioni, ovvero "Actual" e "Predicted". Entrambe le dimensioni hanno "True Positives (TP)", "True Negatives (TN)", "False Positives (FP)", "False Negatives (FN)".
Nella matrice di confusione sopra, 1 è per la classe positiva e 0 è per la classe negativa.
Di seguito sono riportati i termini associati alla matrice di confusione:
True Positives − I TP sono i casi in cui la classe effettiva del punto dati era 1 e anche quella prevista è 1.
True Negatives − I TN sono i casi in cui la classe effettiva del punto dati era 0 e anche quella prevista è 0.
False Positives − I FP sono i casi in cui la classe effettiva del punto dati era 0 e anche il previsto è 1.
False Negatives − Gli FN sono i casi in cui la classe effettiva del punto dati era 1 e anche la previsione è 0.
Precisione
La matrice di confusione in sé non è una misura delle prestazioni in quanto tale, ma quasi tutte le matrici delle prestazioni sono basate sulla matrice di confusione. Uno di questi è la precisione. Nei problemi di classificazione, può essere definito come il numero di previsioni corrette fatte dal modello su tutti i tipi di previsioni fatte. La formula per calcolare la precisione è la seguente:
$$ Precisione = \ frac {TP + TN} {TP + FP + FN + TN} $$
Precisione
Viene utilizzato principalmente nel recupero dei documenti. Può essere definito come quanti dei documenti restituiti sono corretti. Di seguito è riportata la formula per il calcolo della precisione:
$$ Precisione = \ frac {TP} {TP + FP} $$
Richiamo o sensibilità
Può essere definito come quanti degli aspetti positivi restituiscono il modello. Di seguito è riportata la formula per il calcolo del richiamo / sensibilità del modello:
$$ Recall = \ frac {TP} {TP + FN} $$
Specificità
Può essere definito come il numero di negativi restituiti dal modello. È esattamente l'opposto di ricordare. Di seguito è riportata la formula per calcolare la specificità del modello:
$$ Specificità = \ frac {TN} {TN + FP} $$
Problema di squilibrio di classe
Lo squilibrio di classe è lo scenario in cui il numero di osservazioni appartenenti a una classe è significativamente inferiore a quelle appartenenti alle altre classi. Ad esempio, questo problema è prominente nello scenario in cui dobbiamo identificare le malattie rare, le transazioni fraudolente in banca ecc.
Esempio di classi sbilanciate
Consideriamo un esempio di set di dati di rilevamento delle frodi per comprendere il concetto di classe squilibrata -
Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%Soluzione
Balancing the classes’agisce come una soluzione alle classi squilibrate. L'obiettivo principale del bilanciamento delle classi è aumentare la frequenza della classe di minoranza o diminuire la frequenza della classe di maggioranza. Di seguito sono riportati gli approcci per risolvere il problema delle classi di squilibri:
Ricampionamento
Il ricampionamento è una serie di metodi utilizzati per ricostruire i set di dati di esempio, sia set di addestramento che set di test. Il ricampionamento viene eseguito per migliorare l'accuratezza del modello. Di seguito sono riportate alcune tecniche di ricampionamento:
Random Under-Sampling- Questa tecnica mira a bilanciare la distribuzione delle classi eliminando casualmente esempi di classi maggioritarie. Questo viene fatto fino a quando le istanze delle classi di maggioranza e minoranza non sono bilanciate.
Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%In questo caso, stiamo prelevando il 10% di campioni senza sostituzione da istanze non fraudolente e poi li combiniamo con le istanze di frode -
Osservazioni non fraudolente dopo campionamento casuale = 10% di 4950 = 495
Osservazioni totali dopo averle combinate con osservazioni fraudolente = 50 + 495 = 545
Quindi ora, il tasso di eventi per il nuovo set di dati dopo il sottocampionamento = 9%
Il vantaggio principale di questa tecnica è che può ridurre il tempo di esecuzione e migliorare l'archiviazione. D'altro canto, può scartare informazioni utili riducendo il numero di campioni di dati di addestramento.
Random Over-Sampling - Questa tecnica mira a bilanciare la distribuzione delle classi aumentando il numero di istanze nella classe di minoranza replicandole.
Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%Nel caso in cui stiamo replicando 50 osservazioni fraudolente 30 volte, le osservazioni fraudolente dopo aver replicato le osservazioni della classe di minoranza sarebbero 1500. E quindi le osservazioni totali nei nuovi dati dopo il sovracampionamento sarebbero 4950 + 1500 = 6450. Da qui il tasso di eventi per il nuovo set di dati sarebbe 1500/6450 = 23%.
Il vantaggio principale di questo metodo è che non ci sarebbe perdita di informazioni utili. Ma d'altra parte, ha maggiori possibilità di adattamento eccessivo perché replica gli eventi delle classi di minoranza.
Tecniche d'insieme
Questa metodologia viene utilizzata fondamentalmente per modificare gli algoritmi di classificazione esistenti per renderli appropriati per i set di dati sbilanciati. In questo approccio costruiamo diversi classificatori a due fasi dai dati originali e quindi aggreghiamo le loro previsioni. Il classificatore di foresta casuale è un esempio di classificatore basato su un insieme.