Uczenie maszynowe z Pythonem - przygotowywanie danych

Wprowadzenie

Algorytmy uczenia maszynowego są całkowicie zależne od danych, ponieważ jest to najważniejszy aspekt, który umożliwia uczenie modeli. Z drugiej strony, jeśli nie będziemy w stanie wyciągnąć sensu z tych danych, przed przekazaniem ich do algorytmów ML maszyna będzie bezużyteczna. Mówiąc prościej, zawsze musimy podawać właściwe dane, tj. Dane w odpowiedniej skali, formacie i zawierające znaczące cechy, dla problemu, który chcemy rozwiązać przez maszynę.

To sprawia, że ​​przygotowanie danych jest najważniejszym krokiem w procesie ML. Przygotowanie danych można zdefiniować jako procedurę, która sprawia, że ​​nasz zbiór danych jest bardziej odpowiedni dla procesu ML.

Dlaczego wstępne przetwarzanie danych?

Po wybraniu surowych danych do treningu ML najważniejszym zadaniem jest wstępne przetwarzanie danych. W szerokim sensie wstępne przetwarzanie danych przekształci wybrane dane w formę, z którą możemy pracować lub możemy je przesłać do algorytmów ML. Zawsze musimy wstępnie przetwarzać nasze dane, aby były zgodne z oczekiwaniami algorytmu uczenia maszynowego.

Techniki wstępnego przetwarzania danych

Mamy następujące techniki wstępnego przetwarzania danych, które można zastosować na zestawie danych w celu uzyskania danych dla algorytmów ML -

skalowanie

Najprawdopodobniej nasz zbiór danych zawiera atrybuty o różnej skali, ale nie możemy dostarczyć takich danych do algorytmu ML, dlatego wymaga przeskalowania. Przeskalowanie danych zapewnia, że ​​atrybuty są w tej samej skali. Ogólnie atrybuty są przeskalowywane do zakresu od 0 do 1. Algorytmy ML, takie jak gradientowe zejście i k-Nearest Neighbors, wymagają skalowanych danych. Możemy przeskalować dane za pomocą klasy MinMaxScaler biblioteki Python scikit-learn.

Przykład

W tym przykładzie przeskalujemy dane z zestawu danych Pima Indians Diabetes, którego używaliśmy wcześniej. Najpierw zostaną załadowane dane CSV (tak jak to zrobiono w poprzednich rozdziałach), a następnie za pomocą klasy MinMaxScaler zostaną przeskalowane w zakresie 0 i 1.

Pierwsze kilka wierszy poniższego skryptu jest takich samych, jak napisaliśmy w poprzednich rozdziałach podczas ładowania danych 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

Teraz możemy użyć klasy MinMaxScaler do przeskalowania danych w zakresie od 0 do 1.

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

Możemy również podsumować dane wyjściowe według naszego wyboru. Tutaj ustawiamy dokładność na 1 i pokazujemy pierwsze 10 wierszy na wyjściu.

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

Wynik

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

Z powyższego wyniku wszystkie dane zostały przeskalowane do zakresu 0 i 1.

Normalizacja

Inną przydatną techniką wstępnego przetwarzania danych jest normalizacja. Służy do przeskalowania każdego wiersza danych tak, aby miał długość 1. Jest to przydatne głównie w rzadkich zestawach danych, w których mamy dużo zer. Możemy przeskalować dane za pomocą klasy Normalizer biblioteki Python scikit-learn.

Rodzaje normalizacji

W uczeniu maszynowym istnieją dwa typy technik wstępnego przetwarzania normalizacji, jak następuje:

Normalizacja L1

Można ją zdefiniować jako technikę normalizacji, która modyfikuje wartości zbioru danych w taki sposób, że w każdym wierszu suma wartości bezwzględnych będzie zawsze wynosić do 1. Nazywa się ją również najmniejszymi odchyleniami bezwzględnymi.

Example

W tym przykładzie używamy techniki L1 Normalize do znormalizowania danych z zestawu danych Pima Indians Diabetes, którego używaliśmy wcześniej. Najpierw zostaną załadowane dane CSV, a następnie przy pomocy klasy Normalizer zostaną znormalizowane.

Pierwsze kilka wierszy poniższego skryptu jest takich samych, jak napisaliśmy w poprzednich rozdziałach podczas ładowania danych 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

Teraz możemy użyć klasy Normalizer z L1 do normalizacji danych.

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

Możemy również podsumować dane wyjściowe według naszego wyboru. Tutaj ustawiamy dokładność na 2 i pokazujemy pierwsze 3 wiersze na wyjściu.

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

Normalizacja L2

Można ją zdefiniować jako technikę normalizacji, która modyfikuje wartości zbioru danych w taki sposób, że w każdym wierszu suma kwadratów będzie zawsze wynosić do 1. Nazywa się ją również metodą najmniejszych kwadratów.

Example

W tym przykładzie używamy techniki L2 Normalization, aby znormalizować dane ze zbioru danych Pima Indians Diabetes, którego używaliśmy wcześniej. Najpierw dane CSV zostaną załadowane (tak jak zostało to zrobione w poprzednich rozdziałach), a następnie przy pomocy klasy Normalizer zostaną znormalizowane.

Pierwsze kilka wierszy poniższego skryptu jest takich samych, jak napisaliśmy w poprzednich rozdziałach podczas ładowania danych 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

Teraz możemy użyć klasy Normalizer z L1 do normalizacji danych.

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

Możemy również podsumować dane wyjściowe według naszego wyboru. Tutaj ustawiamy dokładność na 2 i pokazujemy pierwsze 3 wiersze na wyjściu.

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

Binaryzacja

Jak sama nazwa wskazuje, jest to technika, za pomocą której możemy uczynić nasze dane binarnymi. Możemy użyć progu binarnego, aby uczynić nasze dane binarnymi. Wartości powyżej tej wartości progowej zostaną przekonwertowane na 1, a poniżej tego progu zostaną przekonwertowane na 0. Na przykład, jeśli wybierzemy wartość progową = 0,5, wówczas wartość zbioru danych powyżej tej wartości progowej będzie równa 1, a poniżej tej wartości - 0. To znaczy dlaczego możemy to nazwaćbinarizing dane lub thresholdingdane. Ta technika jest przydatna, gdy mamy prawdopodobieństwa w naszym zbiorze danych i chcemy przekształcić je w konkretne wartości.

Możemy binaryzować dane za pomocą klasy Binarizer biblioteki Python scikit-learn.

Przykład

W tym przykładzie przeskalujemy dane z zestawu danych Pima Indians Diabetes, którego używaliśmy wcześniej. Najpierw zostaną załadowane dane CSV, a następnie przy pomocy klasy Binarizer zostaną zamienione na wartości binarne, tj. 0 i 1 w zależności od wartości progowej. Przyjmujemy 0,5 jako wartość progową.

Pierwsze kilka wierszy poniższego skryptu jest takich samych, jak napisaliśmy w poprzednich rozdziałach podczas ładowania danych 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

Teraz możemy użyć klasy Binarize do konwersji danych na wartości binarne.

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

Tutaj pokazujemy pierwsze 5 wierszy danych wyjściowych.

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

Wynik

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

Normalizacja

Inna przydatna technika wstępnego przetwarzania danych, która jest zasadniczo używana do transformacji atrybutów danych z rozkładem Gaussa. Różni się średnią i odchyleniem standardowym (odchylenie standardowe) od standardowego rozkładu Gaussa ze średnią równą 0 i odchyleniem standardowym równym 1. Technika ta jest przydatna w algorytmach ML, takich jak regresja liniowa, regresja logistyczna, która zakłada rozkład Gaussa w wejściowym zbiorze danych i generuje lepsze wyniki z przeskalowanymi danymi. Możemy ustandaryzować dane (średnia = 0 i SD = 1) za pomocą klasy StandardScaler biblioteki Python scikit-learn.

Przykład

W tym przykładzie przeskalujemy dane z zestawu danych Pima Indians Diabetes, którego używaliśmy wcześniej. Najpierw dane CSV zostaną załadowane, a następnie przy pomocy klasy StandardScaler zostaną przekonwertowane na rozkład Gaussa ze średnią = 0 i SD = 1.

Pierwsze kilka wierszy poniższego skryptu jest takich samych, jak napisaliśmy w poprzednich rozdziałach podczas ładowania danych 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

Teraz możemy użyć klasy StandardScaler do przeskalowania danych.

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

Możemy również podsumować dane wyjściowe według naszego wyboru. Tutaj ustawiamy dokładność na 2 i pokazujemy pierwsze 5 wierszy na wyjściu.

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

Wynik

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

Etykietowanie danych

Omówiliśmy znaczenie dobrego fata dla algorytmów ML, a także niektórych technik wstępnego przetwarzania danych przed wysłaniem ich do algorytmów ML. Jeszcze jednym aspektem w tym względzie jest etykietowanie danych. Bardzo ważne jest również przesłanie danych do algorytmów ML posiadających odpowiednie oznakowanie. Na przykład, w przypadku problemów z klasyfikacją, na danych znajduje się wiele etykiet w postaci słów, liczb itp.

Co to jest kodowanie etykiet?

Większość funkcji sklearn oczekuje, że dane będą miały etykiety liczbowe, a nie etykiety słów. Dlatego musimy zamienić takie etykiety na etykiety z numerami. Ten proces nazywa się kodowaniem etykiet. Możemy wykonać etykietowe kodowanie danych za pomocą funkcji LabelEncoder () biblioteki Python scikit-learn.

Przykład

W poniższym przykładzie skrypt Pythona wykona kodowanie etykiety.

Najpierw zaimportuj wymagane biblioteki Pythona w następujący sposób -

import numpy as np
from sklearn import preprocessing

Teraz musimy podać etykiety wejściowe w następujący sposób -

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

Następny wiersz kodu utworzy koder etykiet i wytrenuje go.

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

Kolejne wiersze skryptu sprawdzą wydajność, kodując losowo uporządkowaną listę -

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)

Możemy uzyskać listę zakodowanych wartości za pomocą następującego skryptu w Pythonie -

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

Wynik

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