[PYTHON] Kaggle Zusammenfassung: Redhat (Teil 2)
Einführung
Wir werden die Informationen von Kaggle aktualisieren, der in der Vergangenheit teilgenommen hat. Hier werden wir die Dateneinführung von Predicting Red Hat Business Value und die prominente Diskussion im Forum aufgreifen. Informationen zur Dateneinführung und zur grundlegenden Analyse finden Sie unter Kaggle-Zusammenfassung: Red Hat (Teil 1), einer praktischen Code-Zusammenfassung. ..
Dieser Artikel verwendet Python 2.7, Numpy 1.11, Scipy 0.17, Scikit-Learn 0.18, Matplotlib 1.5, Seaborn 0.7, Pandas 0.17. Es wurde bestätigt, dass es an einem Jupiter-Notebook funktioniert. (Bitte ändern Sie% matplotlib inline entsprechend) Wenn Sie beim Ausführen des Beispielskripts Fehler finden, wäre es hilfreich, wenn Sie einen Kommentar abgeben könnten.
Überblick
Wie in Teil 1 erläutert, enthalten die Originaldaten ausreichende Funktionen. Selbst wenn Sie keine ausgeklügelten Methoden anwenden, können Sie eine Punktzahl von 95% oder mehr erzielen. Im Gegenteil, je nachdem, wie die verbleibenden paar Prozent verpackt werden sollen, werden verschiedene Lösungen ausprobiert. Es sind auch Codes erschienen, die vielseitige Methoden und tiefes Lernen für Klassifizierungsprobleme verwenden. In diesem Artikel werden die folgenden vier vorgestellt.
- 1st solution
- 2nd solution
- Vorhersage mit XGBoost
- Tiefes Lernen mit Keras
In 1 und 2 gibt es kein Beispielskript, und 3 und 4 sind Benchmark-Beispielcode.
- 1st solution
Beschreibung des Gewinners Ich werde es posten. Informationen zur Visualisierung der Datenstruktur und -verteilung finden Sie unter hier. Außerdem werden Websites hier angezeigt. Es ist leicht zu verstehen.
Wie Sie beim Lesen von Japanisch sehen können, geht die lange Geschichte endlos weiter und es kommt kein konkreter Code heraus. Die japanische Übersetzung wird im Laufe der Zeit immer komplizierter. Wenn Sie also verwirrt sind, überprüfen Sie bitte den englischen Text oder die verweisende Website. Es ist klar, dass Radder einen ziemlich stressigen Tag hatte, ohne die Lücke zu den drei besten Gruppen zu schließen.
Dieses Modell ist sehr einfach. Es ist sehr wichtig, einen geeigneten Kreuzvalidierungssatz zu erstellen und einen Lebenslaufsatz mit der folgenden Methode zu erstellen.
- Entfernen Sie group_1 = 17304 aus den Zug- und Testdaten. Die Daten in dieser Gruppe belegen 30% der Trainingsdaten und alle haben das Ergebnis = 0.
- Verwenden Sie einen anderen Operator für Gruppe1. Dies liegt daran, dass diese Gruppe mehr als 3000 Daten enthält. (Das ist wichtig)
- Erstellen Sie nach dem Zufallsprinzip nicht geschichtete 5-fache Lebensläufe für Personendateien.
Mein Modellierungskonzept ist ziemlich einfach. Reduzieren Sie das ursprüngliche Problem auf einige kleinere Probleme und kombinieren Sie sie in einem Modell der zweiten Ebene. Ich habe einige Modelle wie folgt hergestellt. a) Wählen Sie eine Aktivität aus der Zeitleiste von Gruppe_1 aus (diesmal habe ich die erste / letzte Aktivität der Zeitleiste verwendet). b) Sammeln Sie alle Aktivitäten von Gruppen mit ähnlichen Ergebnissen c) Komprimieren Sie die Feature-Menge. tf-idf ist besonders nützlich. Die Eigenschaften jeder Variablen wurden berechnet. (Für Personen mit denselben Attributen in jeder Gruppe oder in der gesamten Gruppe) d) Fügen Sie einfache, nicht einfache Funktionen hinzu. (Der Wert von group_1 id, Aktivität in der Gruppe, Personen in der Gruppe, maximales / minimales Datum usw.) Dieses Mal haben wir die Wechselbeziehung zwischen Merkmalsmengen oder Wahrscheinlichkeitsinformationen nicht verwendet. e) Erstellen Sie einen Klassifikator. ** Dieses Mal habe ich nur XGBoost verwendet. ** Es konnte allein 0,84 AUC erreichen. (Es werden keine Leckdaten verwendet)
Um die oben beschriebene Methode ordnungsgemäß durchführen zu können, muss ein weniger verbreiteter CV-Ansatz in Betracht gezogen werden. Diese Zerlegungsmethode basiert auf komprimierten person_id-Daten. Dieser Lebenslauf basiert auf mehreren aggregierten CV-Split-Schemata. Diese Technik funktioniert gut, aber Sie müssen bis zu 15 XGBoosts erstellen und zwei Ebenen erstellen. Diese Art, über den Lebenslauf nachzudenken, ist wichtig, aber ich werde die Erklärung hier weglassen.
Hier stellen wir vier gut funktionierende Modelle der ersten Stufe vor. (Zwei von ihnen funktionieren gut in der öffentlichen LB, die anderen beiden geben die beste CV-Punktzahl im Modell der 2. Ebene.) /qiita.com/TomHortons/items/2a05b72be180eb83a204). Da die Veröffentlichung einschließlich Durchgesickerte Veröffentlichung im Lebenslauf implementiert ist, ist die Vorhersage innerhalb der in ML erlernten Ergebnisgruppe? .. Das Modell der 2. Ebene löst zwei Probleme. Die Vorhersagewahrscheinlichkeit in Bezug auf die Leckinformation und die Vorhersagewahrscheinlichkeit in Bezug auf die Leckinformation. Das Modell selbst ist einfach, es wurden jedoch einige intelligente Funktionen eingeführt, um Zeitänderungen in der Gruppe / Population zu erfassen.
Im obigen Zustand (unter Verwendung eines anständigen Vorhersagemodells) wurde ich mitten im Wettbewerb auf Platz 4 eingestuft. Ich sah Teilnehmer auf dem 3. Platz und darüber, die ihre Punktzahlen von Tag zu Tag verbesserten. Daher dachte ich darüber nach, was sie in der öffentlichen LB manuell entwickelten, um Lecks zu erhöhen (Vorhersage-Auslassungen?). Die öffentliche / private Datenpartition (beim Ausprobieren des Modells) ist zufällig. Einige Leute haben eine handgemachte Testgruppeneinreichung durchgeführt und die von Lecks in einer bestimmten Gruppe nicht betroffenen Personen verwendet, um eine Punktzahl zu erhalten. Dann haben wir die Wahrscheinlichkeit des Ergebnisses für die gesamte Gruppe bestimmt. (???) Um dies zu erreichen, haben wir eine große Anzahl von Einsendungen eingereicht, um die größtmögliche Gruppe_1 zu erhalten, und einige Gruppen mit schlechter Vorhersagegenauigkeit des maschinellen Lernmodells gefunden. In diesem Sinne habe ich einige hervorragende Modelle erstellt. (Das heißt, haben Sie Feineinstellungen am Modell und an der CV-Methode vorgenommen, um neue Modelle zu erstellen, und wiederholt gesendet, damit geeignete Gruppen zufällig in die Testdaten aufgenommen wurden?)
Und in der endgültigen Einreichung haben wir einfach die bisher leistungsstärksten Modelle für LB und CV gemittelt. Überraschenderweise ergab dies die höchste Punktzahl aller Zeiten.
- 2nd solution
Vielleicht, weil Radder (Gewinner) die Meisterschaft mit Drehungen und Wendungen gewonnen hat, sind die Diskussionen an zweiter Stelle und darunter, die intelligentere Lösungen vorgeschlagen haben, in den Foreninterviews beliebter. Hier wird Interview auf Platz 2 beschrieben.
step 1 Wir haben einige Wahrscheinlichkeitskomplementmodelle für die Gruppen erstellt, die in der Trainingsstichprobe enthalten sind. Die folgende Abbildung zeigt die Vorhersagewahrscheinlichkeit der Gruppe 7 in chronologischer Reihenfolge.
In der Trainingsstichprobe beträgt die Wahrscheinlichkeit 1, und an einem anderen Tag nimmt die Wahrscheinlichkeit ab. Die folgende Abbildung zeigt ähnliche Vorhersageergebnisse, zeigt jedoch den gesamten Datenbereich.
step 2 Diesmal sind 34224 verschiedene Gruppen in den Daten. Diese Zahl ist die tatsächliche Stichprobengröße (?), Da die Gruppe aus statistischer Sicht nur ein Objekt ist. Das Problem ist die Merkmalsmenge, die innerhalb der Gruppe unterschiedliche Werte annimmt. Wir haben das Histogramm für alle Gruppen und alle Merkmale berechnet. Die Fächer des Histogramms sind neue Funktionen. Dies wird als "Fuzzy" -Version der Binärcodierung (?) Bezeichnet. Es gibt drei Vorhersagemodelle wie folgt.
A) Logistic regression B) KNN C) XGBoost based public scripts
step 3 Basierend auf dem oben Gesagten werden wir es unter Bezugnahme auf das Feedback von LB verbessern.
3. Vorhersage mit XGBoost
Einführung der effektivsten und allgemeinsten Methode mit XGBoost. Code von Autorencode (Abriosi) Bitte beziehen Sie sich auf den Code von hier. Es ist sehr einfach, es codiert die Kategoriedaten und sagt sie mit XGBoost voraus.
Ich werde nur die Hauptpunkte erklären. Entfernen Sie nach pd.read () char_10. (Weil viele Werte fehlen?)
act_train_data=act_train_data.drop('char_10',axis=1)
act_test_data=act_test_data.drop('char_10',axis=1)
Führen Sie die Funktion act_data_treatment für act_train_data und andere Eingabedaten aus, aus denen char_10 entfernt wurde.
act_train_data = act_data_treatment(act_train_data)
act_test_data = act_data_treatment(act_test_data)
people_data = act_data_treatment(people_data)
Die Funktion act_data_treatment ist wie folgt definiert.
def act_data_treatment(dsname):
dataset = dsname
for col in list(dataset.columns):
if col not in ['people_id', 'activity_id', 'date', 'char_38', 'outcome']:
if dataset[col].dtype == 'object':
dataset[col].fillna('type 0', inplace=True)
dataset[col] = dataset[col].apply(lambda x: x.split(' ')[1]).astype(np.int32)
elif dataset[col].dtype == 'bool':
dataset[col] = dataset[col].astype(np.int8)
dataset['year'] = dataset['date'].dt.year
dataset['month'] = dataset['date'].dt.month
dataset['day'] = dataset['date'].dt.day
dataset['isweekend'] = (dataset['date'].dt.weekday >= 5).astype(int)
dataset = dataset.drop('date', axis = 1)
return dataset
Kurz gesagt, alle Kategoriedaten außer ['people_id', 'activity_id', 'date', 'char_38', 'result'] werden codiert und ['date'] in Jahr, Monat, Tag und Woche unterteilt. Führen Sie dann die Funktion redu_dimen für die verketteten Daten von Zug und Test aus.
whole=pd.concat([train,test],ignore_index=True)
categorical=['group_1','activity_category','char_1_x','char_2_x','char_3_x','char_4_x','char_5_x','char_6_x','char_7_x','char_8_x','char_9_x','char_2_y','char_3_y','char_4_y','char_5_y','char_6_y','char_7_y','char_8_y','char_9_y']
for category in categorical:
whole=reduce_dimen(whole,category,9999999)
X=whole[:len(train)]
X_test=whole[len(train):]
del train
del whole
Die Funktion redu_dimen lautet wie folgt.
def reduce_dimen(dataset,column,toreplace):
for index,i in dataset[column].duplicated(keep=False).iteritems():
if i==False:
dataset.set_value(index,column,toreplace)
return dataset
Codieren Sie die Kategoriedaten von Eingabe X mit OneHotEncoder. Dies vervollständigt die 0- und 1-Sparse-Matrix X_sparse.
enc = OneHotEncoder(handle_unknown='ignore')
enc=enc.fit(pd.concat([X[categorical],X_test[categorical]]))
X_cat_sparse=enc.transform(X[categorical])
X_test_cat_sparse=enc.transform(X_test[categorical])
from scipy.sparse import hstack
X_sparse=hstack((X[not_categorical], X_cat_sparse))
X_test_sparse=hstack((X_test[not_categorical], X_test_cat_sparse))
Konvertieren Sie X_sparse in DMatrix und stellen Sie die Parameter ein. Da es viele Websites gibt, die den Inhalt jedes Parameters detailliert vorstellen, werden hier Erklärungen weggelassen. Es gibt vier Haupttypen: {'max_depth': 10, 'eta': 0,02, 'Silent': 1, 'Objective': 'Binary: Logistic'}.
print("Training data: " + format(X_sparse.shape))
print("Test data: " + format(X_test_sparse.shape))
print("###########")
print("One Hot enconded Test Dataset Script")
dtrain = xgb.DMatrix(X_sparse,label=y)
dtest = xgb.DMatrix(X_test_sparse)
param = {'max_depth':10, 'eta':0.02, 'silent':1, 'objective':'binary:logistic' }
param['nthread'] = 4
param['eval_metric'] = 'auc'
param['subsample'] = 0.7
param['colsample_bytree']= 0.7
param['min_child_weight'] = 0
param['booster'] = "gblinear"
Lernen Sie mit XGBoost, machen Sie Vorhersagen und Sie sind fertig.
watchlist = [(dtrain,'train')]
num_round = 300
early_stopping_rounds=10
bst = xgb.train(param, dtrain, num_round, watchlist,early_stopping_rounds=early_stopping_rounds)
ypred = bst.predict(dtest)
output = pd.DataFrame({ 'activity_id' : test['activity_id'], 'outcome': ypred })
output.head()
Dies gibt Ihnen eine Punktzahl nahe 98%.
4. Tiefes Lernen mit Keras
Es gibt einige Leute, die vorerst den neuronalen Ansatz ausprobiert haben. Grundsätzlich ist Deep Learning selten das beste Modell außer Bilddaten. Da die Korrelation zwischen XGBoost und RandomForest und dem Vorhersageergebnis jedoch gering ist, wird es häufig verwendet, um XGBoost beim Lernen von Ensembles zu stärken. Ich fühle es.
Bei Kaggle im Jahr 2016 war Keras der größte Teil des tiefen Lernens. Hier wird die Klassenklassifizierung mit Keras durchgeführt.
4.1. Bis zum Modellentwurf
Importieren Sie zunächst die Bibliothek.
import pandas as pd
import numpy as np
from scipy import sparse as ssp
import pylab as plt
from sklearn.preprocessing import LabelEncoder,LabelBinarizer,MinMaxScaler,OneHotEncoder
from sklearn.feature_extraction.text import TfidfVectorizer,CountVectorizer
from sklearn.decomposition import TruncatedSVD,NMF,PCA,FactorAnalysis
from sklearn.feature_selection import SelectFromModel,SelectPercentile,f_classif
from sklearn.decomposition import TruncatedSVD
from sklearn.metrics import log_loss,roc_auc_score
from sklearn.pipeline import Pipeline,make_pipeline
from sklearn.cross_validation import StratifiedKFold,KFold
from keras.preprocessing import sequence
from keras.callbacks import ModelCheckpoint,Callback
from keras import backend as K
from keras.layers import Input, Embedding, LSTM, Dense,Flatten, Dropout, merge,Convolution1D,MaxPooling1D,Lambda,AveragePooling1D
from keras.layers.normalization import BatchNormalization
from keras.optimizers import SGD
from keras.layers.advanced_activations import PReLU,LeakyReLU,ELU,SReLU
from keras.models import Model
Bitte installieren Sie Keras und Tensorflow (Theano) im Voraus. Es gibt auch viele Websites auf Japanisch.
Als nächstes folgen die Einstellungen für Datenpfad und Startwert.
seed = 1
np.random.seed(seed)
dim = 32
hidden=64
path = "../input/"
Lesen Sie Zug-, Test- und Personendaten und lassen Sie die verketteten Daten Daten sein. Daten sind eine Variable, die zum Erstellen von Eingabe-, Zwischen- und Ausgabeebenen verwendet wird und nach Abschluss der Modellierung gelöscht wird.
train = pd.read_csv(path+'act_train.csv')
test = pd.read_csv(path+'act_test.csv')
people = pd.read_csv(path+'people.csv')
columns = people.columns
test['outcome'] = np.nan
data = pd.concat([train,test])
data = pd.merge(data,people,how='left',on='people_id').fillna('missing')
train = data[:train.shape[0]]
test = data[train.shape[0]:]
Bis zu diesem Punkt ist die Form von Daten (2695978, 55), bei der es sich um einen DataFrame handelt, der people_id und activity_id enthält.
Legen Sie als Nächstes die Spalteninformationen als Spalten fest und codieren Sie den Wert der Daten mit LabelEncoder von sklearn. Da fehlende Daten enthalten sind, werden sie auf die gleiche Weise wie normale numerische Daten codiert. Es scheint, dass das Programm ziemlich sorgfältig geschrieben ist, also ist das Programm lang. Bitte beachten Sie.
columns = train.columns.tolist()
columns.remove('activity_id')
columns.remove('outcome')
data = pd.concat([train,test])
for c in columns:
data[c] = LabelEncoder().fit_transform(data[c].values)
train = data[:train.shape[0]]
test = data[train.shape[0]:]
data = pd.concat([train,test])
columns = train.columns.tolist()
columns.remove('activity_id')
columns.remove('outcome')
Wenn die Datenvorbereitung abgeschlossen ist, beginnen Sie mit dem Einstellen der Ebene. Bereiten Sie die Eingabeebene und die Einbettungsebene von Keras vor und bereiten Sie die Ebenen gemäß den erstellten Spalten vor. Die Details jeder Ebene sind unter "Eingabe (Einbetten + Reduzieren) + Ebene + Dropout + Ausgabe" in Keras-Fallstudie beschrieben. Wurde weggelassen. Hier ist eine Visualisierung des endgültig fertiggestellten Modells.
4.2 Von der Vorbereitung der Eingabedaten bis zum model.fit
Da die zuvor verwendeten Daten für die Modellerstellung verwendet wurden, bereiten Sie X und y für die Eingabe vor. Klassifizieren Sie Trainings- / Testdaten mit skf und erstellen Sie X_train und X_test.
X = train[columns].values
X_t = test[columns].values
y = train["outcome"].values
people_id = train["people_id"].values
activity_id = test['activity_id']
del train
del test
skf = StratifiedKFold(y, n_folds=4, shuffle=True, random_state=seed)
for ind_tr, ind_te in skf:
X_train = X[ind_tr]
X_test = X[ind_te]
y_train = y[ind_tr]
y_test = y[ind_te]
break
X_train = [X_train[:,i] for i in range(X.shape[1])]
X_test = [X_test[:,i] for i in range(X.shape[1])]
del X
Im Originalcode wird das Modell dann mit ModelCheckpoint gespeichert. Da der Prüfpunkt jedoch nicht in model.fit festgelegt ist, wird hier auf eine ausführliche Erläuterung verzichtet.
Schließlich machen Sie model.fit und model.predict und Sie sind fertig.
model.fit(
X_train,
y_train,
batch_size=batch_size,
nb_epoch=nb_epoch,
verbose=1,
shuffle=True,
validation_data=[X_test,y_test],
callbacks = [
model_checkpoint,
auc_callback,
],
)
Die maximale Vorhersagegenauigkeit beträgt 0,98. Deep Learning ist nicht besonders gut, da die Originaldaten leicht vorherzusagen sind.
Recommended Posts