Apprendimento automatico con Python - Preparazione dei dati

introduzione

Gli algoritmi di Machine Learning dipendono completamente dai dati perché è l'aspetto più cruciale che rende possibile l'addestramento del modello. D'altra parte, se non saremo in grado di dare un senso a quei dati, prima di fornirli agli algoritmi di ML, una macchina sarà inutile. In parole semplici, abbiamo sempre bisogno di alimentare i dati corretti, cioè i dati in scala, formato e caratteristiche significative corretti, per il problema che vogliamo che la macchina risolva.

Ciò rende la preparazione dei dati il ​​passaggio più importante nel processo ML. La preparazione dei dati può essere definita come la procedura che rende il nostro set di dati più appropriato per il processo di ML.

Perché la pre-elaborazione dei dati?

Dopo aver selezionato i dati grezzi per l'addestramento ML, l'attività più importante è la pre-elaborazione dei dati. In senso lato, la preelaborazione dei dati convertirà i dati selezionati in una forma con cui possiamo lavorare o che possiamo fornire agli algoritmi ML. Abbiamo sempre bisogno di preelaborare i nostri dati in modo che possano essere conformi alle aspettative dell'algoritmo di apprendimento automatico.

Tecniche di pre-elaborazione dei dati

Abbiamo le seguenti tecniche di pre-elaborazione dei dati che possono essere applicate al set di dati per produrre dati per algoritmi ML:

Ridimensionamento

Molto probabilmente il nostro set di dati comprende attributi con scala variabile, ma non possiamo fornire tali dati all'algoritmo ML, quindi richiede il ridimensionamento. Il ridimensionamento dei dati garantisce che gli attributi siano sulla stessa scala. In genere, gli attributi vengono ridimensionati nell'intervallo 0 e 1. Gli algoritmi ML come la discesa del gradiente e k-Nearest Neighbors richiedono dati scalati. Possiamo riscalare i dati con l'aiuto della classe MinMaxScaler della libreria Python scikit-learn.

Esempio

In questo esempio riscaleremo i dati del set di dati del diabete degli indiani Pima che abbiamo usato in precedenza. Per prima cosa verranno caricati i dati CSV (come fatto nei capitoli precedenti) e poi con l'aiuto della classe MinMaxScaler verranno riscalati nell'intervallo 0 e 1.

Le prime righe del seguente script sono le stesse che abbiamo scritto nei capitoli precedenti durante il caricamento dei dati CSV.

from pandas import read_csv
from numpy import set_printoptions
from sklearn import preprocessing
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

Ora possiamo usare la classe MinMaxScaler per ridimensionare i dati nell'intervallo 0 e 1.

data_scaler = preprocessing.MinMaxScaler(feature_range=(0,1))
data_rescaled = data_scaler.fit_transform(array)

Possiamo anche riassumere i dati per l'output secondo la nostra scelta. Qui, stiamo impostando la precisione su 1 e mostriamo le prime 10 righe nell'output.

set_printoptions(precision=1)
print ("\nScaled data:\n", data_rescaled[0:10])

Produzione

Scaled data:
[
   [0.4 0.7 0.6 0.4 0.  0.5 0.2 0.5 1. ]
   [0.1 0.4 0.5 0.3 0.  0.4 0.1 0.2 0. ]
   [0.5 0.9 0.5 0.  0.  0.3 0.3 0.2 1. ]
   [0.1 0.4 0.5 0.2 0.1 0.4 0.  0.  0. ]
   [0.  0.7 0.3 0.4 0.2 0.6 0.9 0.2 1. ]
   [0.3 0.6 0.6 0.  0.  0.4 0.1 0.2 0. ]
   [0.2 0.4 0.4 0.3 0.1 0.5 0.1 0.1 1. ]
   [0.6 0.6 0.  0.  0.  0.5 0.  0.1 0. ]
   [0.1 1.  0.6 0.5 0.6 0.5 0.  0.5 1. ]
   [0.5 0.6 0.8 0.  0.  0.  0.1 0.6 1. ]
]

Dall'output sopra, tutti i dati sono stati ridimensionati nell'intervallo 0 e 1.

Normalizzazione

Un'altra tecnica utile per la pre-elaborazione dei dati è la normalizzazione. Viene utilizzato per ridimensionare ogni riga di dati in modo che abbia una lunghezza pari a 1. È utile principalmente nei dataset sparsi in cui abbiamo molti zeri. Possiamo riscalare i dati con l'aiuto della classe Normalizer della libreria Python scikit-learn.

Tipi di normalizzazione

Nell'apprendimento automatico, ci sono due tipi di tecniche di pre-elaborazione della normalizzazione come segue:

Normalizzazione L1

Può essere definita come la tecnica di normalizzazione che modifica i valori del set di dati in modo tale che in ogni riga la somma dei valori assoluti sia sempre fino a 1. Viene anche chiamata Deviazione minima assoluta.

Example

In questo esempio, utilizziamo la tecnica di normalizzazione L1 per normalizzare i dati del set di dati del diabete degli indiani Pima che abbiamo utilizzato in precedenza. Innanzitutto, i dati CSV verranno caricati e quindi con l'aiuto della classe Normalizer verranno normalizzati.

Le prime righe del seguente script sono le stesse che abbiamo scritto nei capitoli precedenti durante il caricamento dei dati CSV.

from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.values

Ora possiamo usare la classe Normalizer con L1 per normalizzare i dati.

Data_normalizer = Normalizer(norm='l1').fit(array)
Data_normalized = Data_normalizer.transform(array)

Possiamo anche riassumere i dati per l'output secondo la nostra scelta. Qui, stiamo impostando la precisione su 2 e mostriamo le prime 3 righe nell'output.

set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])

Output

Normalized data:
[
   [0.02 0.43 0.21 0.1  0. 0.1  0. 0.14 0. ]
   [0.   0.36 0.28 0.12 0. 0.11 0. 0.13 0. ]
   [0.03 0.59 0.21 0.   0. 0.07 0. 0.1  0. ]
]

Normalizzazione L2

Può essere definita come la tecnica di normalizzazione che modifica i valori del set di dati in modo che in ogni riga la somma dei quadrati sia sempre fino a 1. Viene anche chiamata minimi quadrati.

Example

In questo esempio, utilizziamo la tecnica di normalizzazione L2 per normalizzare i dati del set di dati del diabete degli indiani Pima che abbiamo utilizzato in precedenza. Per prima cosa verranno caricati i dati CSV (come fatto nei capitoli precedenti) e poi con l'aiuto della classe Normalizer verranno normalizzati.

Le prime righe del seguente script sono le stesse che abbiamo scritto nei capitoli precedenti durante il caricamento dei dati CSV.

from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.values

Ora possiamo usare la classe Normalizer con L1 per normalizzare i dati.

Data_normalizer = Normalizer(norm='l2').fit(array)
Data_normalized = Data_normalizer.transform(array)

Possiamo anche riassumere i dati per l'output secondo la nostra scelta. Qui, stiamo impostando la precisione su 2 e mostriamo le prime 3 righe nell'output.

set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])

Output

Normalized data:
[
   [0.03 0.83 0.4  0.2  0. 0.19 0. 0.28 0.01]
   [0.01 0.72 0.56 0.24 0. 0.22 0. 0.26 0.  ]
   [0.04 0.92 0.32 0.   0. 0.12 0. 0.16 0.01]
]

Binarizzazione

Come suggerisce il nome, questa è la tecnica con l'aiuto della quale possiamo rendere i nostri dati binari. Possiamo usare una soglia binaria per rendere i nostri dati binari. I valori al di sopra di quel valore di soglia verranno convertiti in 1 e al di sotto di tale soglia verranno convertiti in 0. Ad esempio, se scegliamo il valore di soglia = 0,5, il valore del set di dati sopra di esso diventerà 1 e al di sotto diventerà 0. Ovvero perché possiamo chiamarlobinarizing i dati o thresholdingi dati. Questa tecnica è utile quando abbiamo probabilità nel nostro set di dati e vogliamo convertirle in valori nitidi.

Possiamo binarizzare i dati con l'aiuto della classe Binarizer della libreria Python scikit-learn.

Esempio

In questo esempio, ridimensioneremo i dati del set di dati Pima Indians Diabetes che abbiamo utilizzato in precedenza. Innanzitutto, i dati CSV verranno caricati e quindi con l'aiuto della classe Binarizer verranno convertiti in valori binari, ovvero 0 e 1 a seconda del valore di soglia. Prendiamo 0,5 come valore di soglia.

Le prime righe del seguente script sono le stesse che abbiamo scritto nei capitoli precedenti durante il caricamento dei dati CSV.

from pandas import read_csv
from sklearn.preprocessing import Binarizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

Ora possiamo usare la classe Binarize per convertire i dati in valori binari.

binarizer = Binarizer(threshold=0.5).fit(array)
Data_binarized = binarizer.transform(array)

Qui, stiamo mostrando le prime 5 righe nell'output.

print ("\nBinary data:\n", Data_binarized [0:5])

Produzione

Binary data:
[
   [1. 1. 1. 1. 0. 1. 1. 1. 1.]
   [1. 1. 1. 1. 0. 1. 0. 1. 0.]
   [1. 1. 1. 0. 0. 1. 1. 1. 1.]
   [1. 1. 1. 1. 1. 1. 0. 1. 0.]
   [0. 1. 1. 1. 1. 1. 1. 1. 1.]
]

Standardizzazione

Un'altra utile tecnica di pre-elaborazione dei dati che viene utilizzata fondamentalmente per trasformare gli attributi dei dati con una distribuzione gaussiana. Differisce la media e SD (deviazione standard) da una distribuzione gaussiana standard con una media di 0 e una DS di 1. Questa tecnica è utile negli algoritmi ML come la regressione lineare, la regressione logistica che presuppone una distribuzione gaussiana nel set di dati di input e produce una migliore risultati con dati riscalati. Possiamo standardizzare i dati (media = 0 e SD = 1) con l'aiuto della classe StandardScaler della libreria Python scikit-learn.

Esempio

In questo esempio, ridimensioneremo i dati del set di dati Pima Indians Diabetes che abbiamo utilizzato in precedenza. Prima verranno caricati i dati CSV e poi con l'aiuto della classe StandardScaler verranno convertiti in distribuzione gaussiana con media = 0 e SD = 1.

Le prime righe del seguente script sono le stesse che abbiamo scritto nei capitoli precedenti durante il caricamento dei dati CSV.

from sklearn.preprocessing import StandardScaler
from pandas import read_csv
from numpy import set_printoptions
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

Ora possiamo usare la classe StandardScaler per ridimensionare i dati.

data_scaler = StandardScaler().fit(array)
data_rescaled = data_scaler.transform(array)

Possiamo anche riassumere i dati per l'output secondo la nostra scelta. Qui, stiamo impostando la precisione su 2 e mostriamo le prime 5 righe nell'output.

set_printoptions(precision=2)
print ("\nRescaled data:\n", data_rescaled [0:5])

Produzione

Rescaled data:
[
   [ 0.64  0.85  0.15  0.91 -0.69  0.2   0.47  1.43  1.37]
   [-0.84 -1.12 -0.16  0.53 -0.69 -0.68 -0.37 -0.19 -0.73]
   [ 1.23  1.94 -0.26 -1.29 -0.69 -1.1   0.6  -0.11  1.37]
   [-0.84 -1.   -0.16  0.15  0.12 -0.49 -0.92 -1.04 -0.73]
   [-1.14  0.5  -1.5   0.91  0.77  1.41  5.48 -0.02  1.37]
]

Etichettatura dei dati

Abbiamo discusso l'importanza di una buona fata per gli algoritmi ML e di alcune tecniche per pre-elaborare i dati prima di inviarli agli algoritmi ML. Un altro aspetto a questo proposito è l'etichettatura dei dati. È anche molto importante inviare i dati ad algoritmi ML con un'etichettatura adeguata. Ad esempio, in caso di problemi di classificazione, sui dati sono presenti molte etichette sotto forma di parole, numeri, ecc.

Cos'è la codifica dell'etichetta?

La maggior parte delle funzioni sklearn prevede che i dati abbiano etichette numeriche anziché etichette di parole. Quindi, dobbiamo convertire tali etichette in etichette numeriche. Questo processo è chiamato codifica dell'etichetta. Possiamo eseguire la codifica delle etichette dei dati con l'aiuto della funzione LabelEncoder () della libreria Python scikit-learn.

Esempio

Nell'esempio seguente, lo script Python eseguirà la codifica dell'etichetta.

Innanzitutto, importa le librerie Python richieste come segue:

import numpy as np
from sklearn import preprocessing

Ora, dobbiamo fornire le etichette di input come segue:

input_labels = ['red','black','red','green','black','yellow','white']

La riga di codice successiva creerà il codificatore dell'etichetta e lo addestrerà.

encoder = preprocessing.LabelEncoder()
encoder.fit(input_labels)

Le successive righe di script controlleranno le prestazioni codificando l'elenco ordinato casuale -

test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("\nLabels =", test_labels)
print("Encoded values =", list(encoded_values))
encoded_values = [3,0,4,1]
decoded_list = encoder.inverse_transform(encoded_values)

Possiamo ottenere l'elenco dei valori codificati con l'aiuto del seguente script python -

print("\nEncoded values =", encoded_values)
print("\nDecoded labels =", list(decoded_list))

Produzione

Labels = ['green', 'red', 'black']
Encoded values = [1, 2, 0]
Encoded values = [3, 0, 4, 1]
Decoded labels = ['white', 'black', 'yellow', 'green']