Maschinelles Lernen mit Python - Daten vorbereiten

Einführung

Algorithmen für maschinelles Lernen sind vollständig von Daten abhängig, da dies der wichtigste Aspekt ist, der das Modelltraining ermöglicht. Auf der anderen Seite ist eine Maschine unbrauchbar, wenn wir aus diesen Daten keinen Sinn machen können, bevor wir sie ML-Algorithmen zuführen. Mit einfachen Worten, wir müssen immer die richtigen Daten eingeben, dh die Daten in der richtigen Größe, im richtigen Format und mit aussagekräftigen Merkmalen für das Problem, das die Maschine lösen soll.

Dies macht die Datenaufbereitung zum wichtigsten Schritt im ML-Prozess. Die Datenaufbereitung kann als das Verfahren definiert werden, mit dem unser Datensatz für den ML-Prozess besser geeignet ist.

Warum Datenvorverarbeitung?

Nach Auswahl der Rohdaten für das ML-Training ist die Datenvorverarbeitung die wichtigste Aufgabe. Im weitesten Sinne konvertiert die Datenvorverarbeitung die ausgewählten Daten in eine Form, mit der wir arbeiten oder die wir ML-Algorithmen zuführen können. Wir müssen unsere Daten immer vorverarbeiten, damit sie den Erwartungen des Algorithmus für maschinelles Lernen entsprechen.

Datenvorverarbeitungstechniken

Wir haben die folgenden Datenvorverarbeitungstechniken, die auf einen Datensatz angewendet werden können, um Daten für ML-Algorithmen zu erzeugen:

Skalierung

Höchstwahrscheinlich besteht unser Datensatz aus Attributen mit unterschiedlichem Maßstab, aber wir können solche Daten nicht für den ML-Algorithmus bereitstellen, daher ist eine Neuskalierung erforderlich. Durch die Neuskalierung von Daten wird sichergestellt, dass die Attribute dieselbe Skalierung aufweisen. Im Allgemeinen werden Attribute in den Bereich von 0 bis 1 neu skaliert. ML-Algorithmen wie Gradientenabstieg und k-Nearest Neighbors erfordern skalierte Daten. Wir können die Daten mit Hilfe der MinMaxScaler-Klasse der Scikit-Learn-Python-Bibliothek neu skalieren.

Beispiel

In diesem Beispiel werden die Daten des zuvor verwendeten Pima Indians Diabetes-Datensatzes neu skaliert. Zuerst werden die CSV-Daten geladen (wie in den vorherigen Kapiteln beschrieben) und dann mit Hilfe der MinMaxScaler-Klasse im Bereich von 0 bis 1 neu skaliert.

Die ersten Zeilen des folgenden Skripts sind dieselben wie in den vorherigen Kapiteln beim Laden von CSV-Daten.

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

Jetzt können wir die MinMaxScaler-Klasse verwenden, um die Daten im Bereich von 0 bis 1 neu zu skalieren.

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

Wir können auch die Daten für die Ausgabe nach unserer Wahl zusammenfassen. Hier setzen wir die Genauigkeit auf 1 und zeigen die ersten 10 Zeilen in der Ausgabe an.

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

Ausgabe

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

Aus der obigen Ausgabe wurden alle Daten in den Bereich von 0 und 1 neu skaliert.

Normalisierung

Eine weitere nützliche Datenvorverarbeitungstechnik ist die Normalisierung. Dies wird verwendet, um jede Datenzeile auf eine Länge von 1 neu zu skalieren. Dies ist hauptsächlich in Sparse-Datensätzen nützlich, in denen viele Nullen vorhanden sind. Wir können die Daten mit Hilfe der Normalizer-Klasse der Scikit-Learn-Python-Bibliothek neu skalieren.

Arten der Normalisierung

Beim maschinellen Lernen gibt es zwei Arten von Normalisierungsvorverarbeitungstechniken:

L1 Normalisierung

Es kann als Normalisierungstechnik definiert werden, die die Datensatzwerte so ändert, dass in jeder Zeile die Summe der absoluten Werte immer bis zu 1 beträgt. Sie wird auch als geringste absolute Abweichungen bezeichnet.

Example

In diesem Beispiel verwenden wir die L1-Normalisierungstechnik, um die Daten des zuvor verwendeten Pima-Indianer-Diabetes-Datensatzes zu normalisieren. Zuerst werden die CSV-Daten geladen und dann mit Hilfe der Normalizer-Klasse normalisiert.

Die ersten Zeilen des folgenden Skripts sind dieselben wie in den vorherigen Kapiteln beim Laden von CSV-Daten.

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

Jetzt können wir die Normalizer-Klasse mit L1 verwenden, um die Daten zu normalisieren.

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

Wir können auch die Daten für die Ausgabe nach unserer Wahl zusammenfassen. Hier setzen wir die Genauigkeit auf 2 und zeigen die ersten 3 Zeilen in der Ausgabe an.

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

L2 Normalisierung

Es kann als Normalisierungstechnik definiert werden, die die Datensatzwerte so ändert, dass in jeder Zeile die Summe der Quadrate immer bis zu 1 beträgt. Sie wird auch als kleinste Quadrate bezeichnet.

Example

In diesem Beispiel verwenden wir die L2-Normalisierungstechnik, um die Daten des zuvor verwendeten Pima Indians Diabetes-Datensatzes zu normalisieren. Zuerst werden die CSV-Daten geladen (wie in den vorherigen Kapiteln beschrieben) und dann mit Hilfe der Normalizer-Klasse normalisiert.

Die ersten Zeilen des folgenden Skripts sind dieselben wie in den vorherigen Kapiteln beim Laden von CSV-Daten.

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

Jetzt können wir die Normalizer-Klasse mit L1 verwenden, um die Daten zu normalisieren.

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

Wir können auch die Daten für die Ausgabe nach unserer Wahl zusammenfassen. Hier setzen wir die Genauigkeit auf 2 und zeigen die ersten 3 Zeilen in der Ausgabe an.

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

Binarisierung

Wie der Name schon sagt, ist dies die Technik, mit deren Hilfe wir unsere Daten binär machen können. Wir können einen binären Schwellenwert verwenden, um unsere Daten binär zu machen. Die Werte über diesem Schwellenwert werden in 1 und unter diesem Schwellenwert in 0 konvertiert. Wenn wir beispielsweise den Schwellenwert = 0,5 wählen, wird der darüber liegende Datensatzwert zu 1 und darunter zu 0. Das heißt warum wir es nennen könnenbinarizing die Daten oder thresholdingdie Daten. Diese Technik ist nützlich, wenn wir Wahrscheinlichkeiten in unserem Datensatz haben und diese in klare Werte konvertieren möchten.

Wir können die Daten mit Hilfe der Binarizer-Klasse der Scikit-Learn-Python-Bibliothek binarisieren.

Beispiel

In diesem Beispiel werden die Daten des Pima Indians Diabetes-Datensatzes, den wir zuvor verwendet haben, neu skaliert. Zuerst werden die CSV-Daten geladen und dann mit Hilfe der Binarizer-Klasse in Binärwerte umgewandelt, dh 0 und 1, abhängig vom Schwellenwert. Wir nehmen 0,5 als Schwellenwert.

Die ersten Zeilen des folgenden Skripts sind dieselben wie in den vorherigen Kapiteln beim Laden von CSV-Daten.

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

Jetzt können wir die Binarize-Klasse verwenden, um die Daten in Binärwerte umzuwandeln.

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

Hier zeigen wir die ersten 5 Zeilen in der Ausgabe.

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

Ausgabe

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

Standardisierung

Eine weitere nützliche Datenvorverarbeitungstechnik, die im Wesentlichen verwendet wird, um die Datenattribute mit einer Gaußschen Verteilung zu transformieren. Es unterscheidet den Mittelwert und die SD (Standardabweichung) von einer Standard-Gauß-Verteilung mit einem Mittelwert von 0 und einer SD von 1. Diese Technik ist nützlich bei ML-Algorithmen wie der linearen Regression und der logistischen Regression, die eine Gauß-Verteilung im Eingabedatensatz voraussetzen und besser produzieren Ergebnisse mit neu skalierten Daten. Wir können die Daten (Mittelwert = 0 und SD = 1) mit Hilfe der StandardScaler-Klasse der Scikit-Learn-Python-Bibliothek standardisieren.

Beispiel

In diesem Beispiel werden die Daten des Pima Indians Diabetes-Datensatzes, den wir zuvor verwendet haben, neu skaliert. Zuerst werden die CSV-Daten geladen und dann mit Hilfe der StandardScaler-Klasse in die Gaußsche Verteilung mit Mittelwert = 0 und SD = 1 konvertiert.

Die ersten Zeilen des folgenden Skripts sind dieselben wie in den vorherigen Kapiteln beim Laden von CSV-Daten.

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

Jetzt können wir die StandardScaler-Klasse verwenden, um die Daten neu zu skalieren.

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

Wir können auch die Daten für die Ausgabe nach unserer Wahl zusammenfassen. Hier setzen wir die Genauigkeit auf 2 und zeigen die ersten 5 Zeilen in der Ausgabe an.

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

Ausgabe

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

Datenbeschriftung

Wir haben die Bedeutung guter Fata für ML-Algorithmen sowie einige Techniken zur Vorverarbeitung der Daten vor dem Senden an ML-Algorithmen erörtert. Ein weiterer Aspekt in dieser Hinsicht ist die Datenkennzeichnung. Es ist auch sehr wichtig, die Daten an ML-Algorithmen mit korrekter Kennzeichnung zu senden. Beispielsweise sind bei Klassifizierungsproblemen viele Beschriftungen in Form von Wörtern, Zahlen usw. auf den Daten vorhanden.

Was ist Etikettencodierung?

Die meisten sklearn-Funktionen erwarten, dass die Daten eher mit Zahlenbezeichnungen als mit Wortbezeichnungen versehen sind. Daher müssen wir solche Bezeichnungen in Zahlenbezeichnungen umwandeln. Dieser Vorgang wird als Etikettencodierung bezeichnet. Wir können die Label-Codierung von Daten mit Hilfe der LabelEncoder () -Funktion der scikit-learn Python-Bibliothek durchführen.

Beispiel

Im folgenden Beispiel führt das Python-Skript die Etikettencodierung durch.

Importieren Sie zunächst die erforderlichen Python-Bibliotheken wie folgt:

import numpy as np
from sklearn import preprocessing

Jetzt müssen wir die Eingabebeschriftungen wie folgt bereitstellen:

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

In der nächsten Codezeile wird der Beschriftungscodierer erstellt und trainiert.

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

In den nächsten Skriptzeilen wird die Leistung überprüft, indem die zufällig geordnete Liste codiert wird.

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)

Wir können die Liste der codierten Werte mit Hilfe des folgenden Python-Skripts erhalten -

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

Ausgabe

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