[Python] Datenanalyse, maschinelles Lernen (Kaggle) -Datenvorverarbeitung-

Einführung

Vorheriger Artikel [Python] Erste Datenanalyse / maschinelles Lernen (Kaggle) [Python] Erste Datenanalyse / Maschinelles Lernen (Kaggle) ~ Part2 ~ Im Anschluss daran forderten wir den relativ sanften Wettbewerb "Hauspreise: Fortgeschrittene Regressionstechniken" bei Kaggle heraus!

Der Wettbewerb besteht diesmal darin, den Preis eines Hauses anhand der Variablen der Informationen über das Haus zu schätzen. Es gibt jedoch 80 Variablen, die mit diesem Haus zusammenhängen, und ich bekam plötzlich Angst ... (lacht)

Während ich dachte "Ist das möglich?", Leihte ich mir auch diesmal die Weisheit meiner Vorfahren! Lol Referenzcode ↓↓↓

• Stacked Regressions : Top 4% on LeaderBoard
• Comprehensive data exploration with Python

Der allgemeine Fluss ist wie folgt.

1. Feature Engineering
2. ** Fehlende Werte eingeben ** Fehlende Werte eingeben
3. ** Transformation ** Datentransformation (Protokolltransformation usw.)
4. ** Label Encoding ** Codierung kategorialer Daten
5. ** Box Cox Transformation **: Transformation, um sie einer Normalverteilung näher zu bringen
6. ** Dummy-Variablen abrufen ** Kategoriale Daten in numerische Daten konvertieren
7. Modellierung (Stapeln von Ensemble-Lernen)
8. Basismodellanalyse
9. Zweite Modellanalyse

Und in diesem Artikel konzentrieren wir uns auf ** Feature Engineering **!

Datenerfassung / Bibliotheksimport

#Bibliotheksimport

import numpy as np #Lineare Algebra
import pandas as pd #Datenverarbeitung, Betrieb der CSV-Datei
%matplotlib inline
import matplotlib.pyplot as plt  # Matlab-style plotting
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
    pass
warnings.warn = ignore_warn #Ignorieren Sie unnötige Warnungen(from sklearn and seaborn)


from scipy import stats
from scipy.stats import norm, skew #Statistische Operationen

pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x)) #Dezimalpunkt setzen

from subprocess import check_output
print(check_output(["ls", "../input"]).decode("utf8")) #Überprüfen Sie, ob die Datei gültig ist

Ausgabe

data_description.txt
sample_submission.csv
test.csv
train.csv

Datenrahmenerstellung

#Daten abrufen, Datenrahmen erstellen
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')

Werfen wir einen Blick auf den Datenrahmen!

##Anzeigen von Datenrahmen
train.head(5)

#Anzahl der Beispiele und Funktionen
print("The train data size before dropping Id feature is : {} ".format(train.shape))
print("The test data size before dropping Id feature is : {} ".format(test.shape))

#'Id'Spalte speichern
train_ID = train['Id']
test_ID = test['Id']

#Die ID ist im Vorhersageprozess nicht erforderlich. Löschen Sie sie daher
train.drop("Id", axis = 1, inplace = True)
test.drop("Id", axis = 1, inplace = True)

#Überprüfen Sie erneut, ob die ID verschwunden ist
print("\nThe train data size after dropping Id feature is : {} ".format(train.shape)) 
print("The test data size after dropping Id feature is : {} ".format(test.shape))

Ausgabe

The train data size before dropping Id feature is : (1460, 81) 
The test data size before dropping Id feature is : (1459, 80) 

The train data size after dropping Id feature is : (1460, 80) 
The test data size after dropping Id feature is : (1459, 79) 

1460 Trainingsdaten, 80 Funktionen Es gibt 1459 Testdaten und 79 Funktionen!

Eh, ** Zu viele Funktionen! !! ** ** ** Wie soll ich das analysieren?

** Lassen Sie uns vorerst fehlende Werte, Verzerrungen und kategoriale Daten digitalisieren **!

Datenvorverarbeitung

Beginnen wir mit den fehlenden Werten! Grundsätzlich * Es ist in Ordnung, Funktionen mit einer Datenverlustrate von 15% oder mehr zu löschen !! *

1. Fehlender Wert

** Integrieren Sie die Daten einmal, um ** gemeinsam fehlende Werte ** mit dem Zug der Trainingsdaten und dem Test der Testdaten zu behandeln!

ntrain = train.shape[0]
ntest = test.shape[0]
y_train = train.SalePrice.values
all_data = pd.concat((train, test)).reset_index(drop=True)
all_data.drop(['SalePrice'], axis=1, inplace=True)
print("all_data size is : {}".format(all_data.shape))

Ausgabe

all_data size is : (2917, 79)

Die Anzahl der Daten beträgt 2917 und die Anzahl der Funktionen beträgt 79, daher wurde es gut integriert!

Effiziente Identifizierung von Features mit fehlenden Werten

** 1. Berechnen Sie die fehlende Rate aller Features und fügen Sie das Feature mit der fehlenden Wertrate> 0 in einen neuen Datenrahmen ein ** ** 2. Visualisieren Sie die Fehlerrate ** ** 3. Löschen oder Zuweisen von Werten für jede Funktion **

Wir werden fehlende Werte in diesem Ablauf verarbeiten!

** 1. Berechnen Sie die fehlende Rate aller Features und fügen Sie das Feature mit der Rate fehlender Werte> 0 in einen neuen Datenrahmen ein **

all_data_na = (all_data.isnull().sum() / len(all_data)) * 100
all_data_na = all_data_na.drop(all_data_na[all_data_na == 0].index).sort_values(ascending=False)[:30]#Extrahieren Sie nur Variablen, die fehlende Werte enthalten
missing_data = pd.DataFrame({'Missing Ratio' :all_data_na})#Fügen Sie einen Datenrahmen ein.
missing_data.head(20)

Ausgabe

** 2. Visualisieren Sie die Fehlerrate **

f, ax = plt.subplots(figsize=(15, 12))
plt.xticks(rotation='90')
sns.barplot(x=all_data_na.index, y=all_data_na)
plt.xlabel('Features', fontsize=15)
plt.ylabel('Percent of missing values', fontsize=15)
plt.title('Percent missing data by feature', fontsize=15)

** 3. Löschen oder Zuweisen von Werten für jede Funktion ** Wir werden Werte für die Features eingeben, einschließlich der fehlenden Werte, die in der obigen Grafik gezeigt werden! Es ist ein wenig schwierig, weil wir jedes Feature einzeln betrachten, aber wir werden es tun!

• ** PoolQC **: Meist fehlende Werte. Geben Sie None in den fehlenden Wert ein, um "kein Pool" zu bedeuten.

all_data["PoolQC"] = all_data["PoolQC"].fillna("None")

• ** MiscFeature **: Gemäß der Datenbeschreibung bedeutet NA "keine anderen Merkmale". Setzen Sie None für fehlende Werte

all_data["MiscFeature"] = all_data["MiscFeature"].fillna("None")

• ** Gasse **: Laut Datenbeschreibung bedeutet dies "kein Zugang zur Gasse". Setzen Sie None für fehlende Werte

all_data["Alley"] = all_data["Alley"].fillna("None")

• ** Zaun **: Bedeutet "kein Zaun". Setzen Sie None für fehlende Werte

all_data["Fence"] = all_data["Fence"].fillna("None")

• ** FireplaceQu **: Bedeutet "kein Kamin". Setzen Sie None für fehlende Werte

all_data["FireplaceQu"] = all_data["FireplaceQu"].fillna("None")

• ** LotFrontage **: Ersetzen Sie den fehlenden Wert durch den Durchschnittswert des Nachbarhauses Median () erhält übrigens den Durchschnittswert

#Gruppieren Sie nach Stadtteilen und ersetzen Sie den fehlenden Wert durch die durchschnittliche LotFrontage der Gruppe
all_data["LotFrontage"] = all_data.groupby("Neighborhood")["LotFrontage"].transform(
    lambda x: x.fillna(x.median()))

• ** GarageType, GarageFinish, GarageQual und GarageCond **: Füllen Sie fehlende Werte mit None

for col in ('GarageType', 'GarageFinish', 'GarageQual', 'GarageCond'):
    all_data[col] = all_data[col].fillna('None')

• ** GarageYrBlt, GarageArea und GarageCars **: Setzen Sie 0 in den fehlenden Wert

for col in ('GarageYrBlt', 'GarageArea', 'GarageCars'):
    all_data[col] = all_data[col].fillna(0)

• ** BsmtFinSF1, BsmtFinSF2, BsmtUnfSF, TotalBsmtSF, BsmtFullBath und BsmtHalfBath **: Setzen Sie 0 in den fehlenden Wert

for col in ('BsmtFinSF1', 'BsmtFinSF2', 'BsmtUnfSF','TotalBsmtSF', 'BsmtFullBath', 'BsmtHalfBath'):
    all_data[col] = all_data[col].fillna(0)

• ** BsmtQual, BsmtCond, BsmtExposure, BsmtFinType1 und BsmtFinType2 **: Geben Sie None in den fehlenden Wert der kategorialen Daten ein

for col in ('BsmtQual', 'BsmtCond', 'BsmtExposure', 'BsmtFinType1', 'BsmtFinType2'):
    all_data[col] = all_data[col].fillna('None')

• ** MasVnrArea und MasVnrType **: Geben Sie None für type und 0 für Area ein

all_data["MasVnrType"] = all_data["MasVnrType"].fillna("None")
all_data["MasVnrArea"] = all_data["MasVnrArea"].fillna(0)

• ** MSZoning (die allgemeine Zoneneinteilung) **: „RL“ ist der Wert, der am weitesten vom Durchschnittswert entfernt ist. Setzen Sie daher RL in den fehlenden Wert.

all_data['MSZoning'] = all_data['MSZoning'].fillna(all_data['MSZoning'].mode()[0])

• ** Dienstprogramme **: Entfernt, weil es nutzlos ist

all_data = all_data.drop(['Utilities'], axis=1)

• ** Funktional **: NA ist typisch, geben Sie also Typ ein

all_data["Functional"] = all_data["Functional"].fillna("Typ")

• ** Elektrik **: Es fehlt nur ein Wert. Dies beinhaltet sBkrk mode (): Ermittelt den häufigsten Wert

all_data['Electrical'] = all_data['Electrical'].fillna(all_data['Electrical'].mode()[0])

• ** KitchenQual **: Geben Sie den häufigsten Wert für nur einen fehlenden Wert ein

all_data['KitchenQual'] = all_data['KitchenQual'].fillna(all_data['KitchenQual'].mode()[0])

• ** Exterior1st und Exterior2nd **: Setzen Sie den häufigsten Wert in den fehlenden Wert

all_data['Exterior1st'] = all_data['Exterior1st'].fillna(all_data['Exterior1st'].mode()[0])
all_data['Exterior2nd'] = all_data['Exterior2nd'].fillna(all_data['Exterior2nd'].mode()[0])

• ** SaleType **: Häufigster Wert

all_data['SaleType'] = all_data['SaleType'].fillna(all_data['SaleType'].mode()[0])

• ** MSSubClass **: Gib keine in Nan

all_data['MSSubClass'] = all_data['MSSubClass'].fillna("None")

Überprüfen Sie die verbleibenden fehlenden Werte

#Überprüfen Sie, ob Werte fehlen
all_data_na = (all_data.isnull().sum() / len(all_data)) * 100
all_data_na = all_data_na.drop(all_data_na[all_data_na == 0].index).sort_values(ascending=False)
missing_data = pd.DataFrame({'Missing Ratio' :all_data_na})
missing_data.head()

Keine fehlenden Werte Damit ist die Verarbeitung fehlender Werte abgeschlossen! Da waren viele ...

2. Kategoriedatenverarbeitung

Kategoriedaten sind Daten, die durch eine Nominalskala oder eine Ordnungsskala dargestellt werden. Grob gesagt sind es nicht numerische Daten!

Wenn die Kategoriedaten erhalten bleiben, können sie nicht analysiert oder gelernt werden, daher werden wir sie quantifizieren!

Verarbeitung von Ordnungsskalendaten

Auftragsskalendaten sind Daten, die nur in der Reihenfolge von Bedeutung sind. Beispielsweise wird die Größe "s, M, L" eines Fast-Food-Getränks als s → 0, M → 1, L → 2 quantifiziert. Bei Ordnungsdaten ist zu beachten, dass ** numerische Berechnungen wie Mittelwert und Standardabweichung nicht möglich sind **.

Konvertieren Sie zunächst den numerischen Wert der Bestelldaten in Zeichendaten. (Später, um die Kategoriedaten zusammen zu quantifizieren)

#MSSubClass=The building class
all_data['MSSubClass'] = all_data['MSSubClass'].apply(str)


#Changing OverallCond into a categorical variable
all_data['OverallCond'] = all_data['OverallCond'].astype(str)


#Year and month sold are transformed into categorical features.
all_data['YrSold'] = all_data['YrSold'].astype(str)
all_data['MoSold'] = all_data['MoSold'].astype(str)

Konvertieren Sie Kategoriedaten in numerische Daten

Mit LabelEncoder () werden die Bestelldaten und die Nenndaten zusammen digitalisiert! Daten mit .fit auswählen, mit .transform () in numerischen Wert konvertieren, Referenz: Verwendung von LabelEncoder von scikit-learn

from sklearn.preprocessing import LabelEncoder
cols = ('FireplaceQu', 'BsmtQual', 'BsmtCond', 'GarageQual', 'GarageCond', 
        'ExterQual', 'ExterCond','HeatingQC', 'PoolQC', 'KitchenQual', 'BsmtFinType1', 
        'BsmtFinType2', 'Functional', 'Fence', 'BsmtExposure', 'GarageFinish', 'LandSlope',
        'LotShape', 'PavedDrive', 'Street', 'Alley', 'CentralAir', 'MSSubClass', 'OverallCond', 
        'YrSold', 'MoSold')
# process columns, apply LabelEncoder to categorical features
for c in cols:
    lbl = LabelEncoder() 
    lbl.fit(list(all_data[c].values)) 
    all_data[c] = lbl.transform(list(all_data[c].values))

# shape        
print('Shape all_data: {}'.format(all_data.shape))

Ausgabe

Shape all_data: (2917, 78)

Ergänzung 1: Hinzufügung neuer Funktionen

Da auch die Fläche aller Stockwerke wichtig ist, werden wir den Gesamtwert von TotalBsmtSF, 1stSF und 2ndFlrSF zum neuen Spezialgrab hinzufügen!

# Adding total sqfootage feature 
all_data['TotalSF'] = all_data['TotalBsmtSF'] + all_data['1stFlrSF'] + all_data['2ndFlrSF']

3. Übertragen Sie die Daten zur Normalverteilung

Beim maschinellen Lernen wird gesagt, dass ** es genauer ist, wenn die Daten einer Normalverteilung folgen **! Schauen Sie sich also zuerst die aktuelle ** Datenverzerrung an (wie weit sie von der Normalverteilung entfernt ist) und lassen Sie Box Cox die Daten der Normalverteilung folgen! ** ** **

1. Zunächst der Grad der Datenverzerrung

numeric_feats = all_data.dtypes[all_data.dtypes != "object"].index

# Check the skew of all numerical features
skewed_feats = all_data[numeric_feats].apply(lambda x: skew(x.dropna())).sort_values(ascending=False)
print("\nSkew in numerical features: \n")
skewness = pd.DataFrame({'Skew' :skewed_feats})
skewness.head(10)

Immerhin können Sie mehrere Funktionen sehen, die nicht normal verteilt sind!

2. Mit BoxCox auf Normalverteilung umstellen!

skewness = skewness[abs(skewness) > 0.75]
print("There are {} skewed numerical features to Box Cox transform".format(skewness.shape[0]))

from scipy.special import boxcox1p
skewed_features = skewness.index
lam = 0.15
for feat in skewed_features:
    #all_data[feat] += 1
    all_data[feat] = boxcox1p(all_data[feat], lam)
    
#all_data[skewed_features] = np.log1p(all_data[skewed_features])

4. Fügen Sie abschließend der kategorialen Funktion eine Dummy-Variable hinzu!

Wenn Sie eine Dummy-Variable verwenden, wird die Variable so festgelegt, dass die kategorialen Daten durch 0,1 dargestellt werden. Referenz: [Erstellen von Dummy-Variablen und Vorsichtsmaßnahmen](https://newtechnologylifestyle.net/%E3%83%80%E3%83%9F%E3%83%BC%E5%A4%89%E6%95% B0% E3% 81% AE% E4% BD% 9C% E3% 82% 8A% E6% 96% B9% E3% 81% A8% E6% B3% A8% E6% 84% 8F% E7% 82% B9% E3% 81% AB% E3% 81% A4% E3% 81% 84% E3% 81% A6 /)

all_data = pd.get_dummies(all_data)
print(all_data.shape)

Ausgabe

(2917, 220)

3. Feature Quantity Engineering abgeschlossen

Damit ist die Datenvorverarbeitung abgeschlossen!

Teilen wir die kombinierten Trainings- und Testdaten auf!

train = all_data[:ntrain]
test = all_data[ntrain:]

Zusammenfassung

Dieses Mal haben wir uns auf die ** Datenvorverarbeitung ** des Kaggle-Wettbewerbs zur Preisprognose für Wohngrundstücke konzentriert! Es gibt 80 Funktionen, und es war anfangs ziemlich schwierig, aber ich denke, ich könnte es richtig handhaben, indem ich die folgenden Schritte befolge!

Datenvorverarbeitungsverfahren ** 1. Integration von Zug- und Testdaten ** ** 2. Fehlende Wertverarbeitung ** ** 3. Kategoriedatenverarbeitung **

Im nächsten Artikel werden wir tatsächlich anhand eines Modells lernen und vorhersagen! !!

Vielen Dank für Ihre Anzeige! !!