[PYTHON] Annäherungserklärung für Anfänger, um in Kaggle Titanic_3 unter den besten 1,5% (0,83732) zu sein

Nach Letztes Mal erreichte Kaggle Titanic die besten 1,5% (0,83732). Ich werde den Ansatz von erklären. Der zu verwendende Code ist titanic (0.83732) _3 von Github. Ich werde erklären, wie Sie sich von der in Letztes Mal angegebenen Punktzahl auf 0,83732 verbessern können.

1. Importieren Sie die erforderliche Bibliothek und laden Sie die CSV.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import RandomForestRegressor
from sklearn.pipeline import Pipeline,make_pipeline
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectKBest
from sklearn import model_selection
from sklearn.model_selection import GridSearchCV
import warnings
warnings.filterwarnings('ignore')

#Lesen Sie CSV
train= pd.read_csv("train.csv")
test= pd.read_csv("test.csv")

#Datenintegration
dataset = pd.concat([train, test], ignore_index = True)

#Zur Einreichung
PassengerId = test['PassengerId']

#Vergleich der Überlebensrate nach Raumebene
dataset['Cabin'] = dataset['Cabin'].fillna('Unknown') #Ersetzen Sie Unbekannt, wenn Raumdaten fehlen
dataset['Deck']= dataset['Cabin'].str.get(0) #Holen Sie sich den ersten Buchstaben (0. Buchstabe) der Kabine (Zimmernummer)

#Vergleich der Überlebensrate anhand der Anzahl der Zeichen im Ticket
Ticket_Count = dict(dataset['Ticket'].value_counts()) #Gruppieren Sie nach der Anzahl der Zeichen im Ticket
dataset['TicketGroup'] = dataset['Ticket'].apply(lambda x:Ticket_Count[x]) #Gruppenverteilung

#Teilen Sie sich in zwei Gruppen ein, eine mit einer hohen Überlebensrate und die andere mit einer niedrigen Überlebensrate, basierend auf der Anzahl der Zeichen im Ticket.
#Ersetzen Sie 2, wenn hoch, und 1, wenn niedrig
def Ticket_Label(s):
    if (s >= 2) & (s <= 4): #Gruppe mit hoher Überlebensrate in der Anzahl der Charaktere
        return 2
    elif ((s > 4) & (s <= 8)) | (s == 1): #Gruppe mit niedriger Überlebensrate in der Anzahl der Charaktere
        return 1
    elif (s > 8):
        return 0

dataset['TicketGroup'] = dataset['TicketGroup'].apply(Ticket_Label)

2. Verwenden Sie den Titel

Wenn wir uns den Code der Kaggle-Top-Performer ansehen, können wir sehen, dass die Verwendung des Titels des Namens der Schlüssel zu einer hohen Punktzahl ist. Titel sind Herr, Frau, Fräulein usw., die in der Mitte des Namens enthalten sind. Berufe wie Dr. (Arzt) und Rev. (Priester und Pastor) können ohne Verwendung von Mr. Extrahieren und gruppieren Sie diese Informationen.

# 'Honorifics'(Titel)Teilen Sie durch Merkmale durch
dataset['Honorifics'] = dataset['Name'].apply(lambda x:x.split(',')[1].split('.')[0].strip()) #Titel(','Wann'.'Wörter zwischen)Extrakt

#Gruppentitel
#Beispiel:'Capt', 'Col', 'Major', 'Dr', 'Rev'Ist'Officer'Zu
Honorifics_Dict = {}
Honorifics_Dict.update(dict.fromkeys(['Capt', 'Col', 'Major', 'Dr', 'Rev'], 'Officer'))
Honorifics_Dict.update(dict.fromkeys(['Don', 'Sir', 'the Countess', 'Dona', 'Lady'], 'Royalty'))
Honorifics_Dict.update(dict.fromkeys(['Mme', 'Ms', 'Mrs'], 'Mrs'))
Honorifics_Dict.update(dict.fromkeys(['Mlle', 'Miss'], 'Miss'))
Honorifics_Dict.update(dict.fromkeys(['Mr'], 'Mr'))
Honorifics_Dict.update(dict.fromkeys(['Master','Jonkheer'], 'Master'))
dataset['Honorifics'] = dataset['Honorifics'].map(Honorifics_Dict)
sns.barplot(x="Honorifics", y="Survived", data=dataset, palette='Set3')

"""Liste der Titel
Herr: Mann,Meister: Junge,Jonkheer: Niederländischer Aristokrat(Mann),
Mlle: Mademoiselle(Französische unverheiratete Frau),Fräulein: unverheiratete Frauen, Mädchen,Frau: Frau(Französische verheiratete Frau),Frau: weiblich(Unverheiratet oder verheiratet),Frau: Verheiratete Frau, 
Don: Mann(Spanien),Sir: Mann(England),die Gräfin: Gräfin,Dona: Verheiratete Frau(Spanien),Dame: Verheiratete Frau(England),
Capt: Captain,Col: Colonel,Hauptfach: Militär,Dr: Doktor,Rev: Priester und Minister
"""

Immerhin haben erwachsene Männer eine niedrige Überlebensrate und Frauen und Kinder eine hohe Überlebensrate. Aber diesmal können wir feststellen, dass königliche Gruppen wie Aristokraten höher sind als Kinder. Ich denke, Sie können sehen, dass die Aristokraten dieser Ära priorisiert und gerettet werden. Es scheint eine Waffe zu sein, als Daten zu verwenden, ob Sie ein Adliger in Bezug auf die Überlebensrate sind oder nicht.

3. Überprüfen Sie die Zuordnung fehlender Werte

Letztes Mal und Letztes Mal setzen den Medianwert vorerst in den fehlenden Wert. Überprüfen Sie diese, um die Genauigkeit Ihrer Vorhersagen zu verbessern.

3.1 Überprüfung fehlender Werte für 'Alter'

Ersetzen Sie das, was durch maschinelles Lernen vorhergesagt wurde, durch den fehlenden Wert des Alters Es scheint, dass die zuvor erwähnten Titel- (Berufs-) Daten auch zur Vorhersage verwendet werden können. (Dr. kann die Vorhersage von 5 Jahren unterdrücken)

##Fehlende Alterswerte vorhersagen und ersetzen
#Extrahieren Sie Elemente, die für die Altersvorhersage verwendet werden, und erstellen Sie Dummy-Variablen
age = dataset[['Age','Pclass','Sex','Honorifics']]
age_dummies = pd.get_dummies(age)
age_dummies.head(3)

#Teilen Sie in diejenigen mit bekanntem Alter und diejenigen mit fehlendem Alter
known_age = age_dummies[age_dummies.Age.notnull()].as_matrix()
null_age = age_dummies[age_dummies.Age.isnull()].as_matrix()

#Teilen Sie in Merkmalsmenge und korrekte Antwortdaten auf
age_X = known_age[:, 1:]
age_y = known_age[:, 0]

#Erstellen Sie ein Altersvorhersagemodell und ersetzen Sie den vorhergesagten Wert
rf = RandomForestRegressor()
rf.fit(age_X, age_y)
pred_Age = rf.predict(null_age[:, 1:])
dataset.loc[(dataset.Age.isnull()),'Age'] = pred_Age

3.2 Überprüfung fehlender Werte für 'Embarked' (Abfahrtshafen)

Überprüfen Sie als Nächstes die fehlenden Daten, um die fehlenden Werte für 'Embarked' einzugeben.

# 'Embarked'(Ausgangspunkt)Fehlende Daten anzeigen
dataset[dataset['Embarked'].isnull()]

In beiden Fällen beträgt die 'P-Klasse' (Ticketklasse) 1 und der 'Tarif' (Gebühr) 80. Vergleicht man den Median 'Tarif' (Gebühr) für jedes 'Eingeborene' mit einer 'Klasse' von 1, so ist C am nächsten. Ersetzen Sie die beiden fehlenden Werte durch C.

# 'Pclass'(Ticketklasse)Ist 1,'Embarked'(Ausgangspunkt)Jeder'Fare'(Gebühr)Median anzeigen
C = dataset[(dataset['Embarked']=='C') & (dataset['Pclass'] == 1)]['Fare'].median()
print("Medianwert von C.", C)
S = dataset[(dataset['Embarked']=='S') & (dataset['Pclass'] == 1)]['Fare'].median()
print("Medianwert von S.", S)
Q = dataset[(dataset['Embarked']=='Q') & (dataset['Pclass'] == 1)]['Fare'].median()
print("Median Q.", Q)

# 'Embarked'Ersetzen Sie den fehlenden Wert von durch C.
dataset['Embarked'] = dataset['Embarked'].fillna('C')

Median C 76,7292 Median S 52.0 Median Q 90.0

3.3 Überprüfung fehlender Werte für 'Tarif'

Wenn Sie sich die Daten ansehen, können Sie sehen, dass die 'P-Klasse' (Ticketklasse) 3 und die 'Embarked' (Abfahrtshafen) 'S' ist. Ersetzen Sie daher diesen fehlenden Wert durch den Medianwert von 'Klasse' (Ticketklasse) von 3 und 'Eingebettet' (Abfahrtshafen) von 'S'. Nachdem Sie die fehlenden Werte für Alter, Einschiffung und Tarif eingegeben haben, überprüfen Sie sie.

# 'Fare'(Gebühr)Fehlende Daten anzeigen
dataset[dataset['Fare'].isnull()]

# 'Pclass'(Ticketklasse)Ist 3'Embarked'(Ausgangspunkt)Aber'S'Ersetzen Sie den Medianwert von
fare_median=dataset[(dataset['Embarked'] == "S") & (dataset['Pclass'] == 3)].Fare.median()
dataset['Fare']=dataset['Fare'].fillna(fare_median)

#Überprüfen Sie die Gesamtzahl der fehlenden Daten
dataset_null = dataset.fillna(np.nan)
dataset_null.isnull().sum()

Age 0 Cabin 0 Embarked 0 Fare 0 Name 0 Parch 0 PassengerId 0 Pclass 0 Sex 0 SibSp 0 Survived 418 Ticket 0 Deck 0 TicketGroup 0 Honorifics 0 dtype: int64

Es fehlen keine Werte.

4. Anzahl der Familienmitglieder

Zweimal zuvor Verarbeitet die Anzahl der Geschwister / Ehepartner und die Anzahl der Eltern / Kinder an Bord, die nicht gut in verwendbare Daten umgewandelt werden konnten. Gruppieren Sie die Familien an Bord und gruppieren Sie sie nach der Überlebensrate nach der Anzahl der Familienmitglieder an Bord.

#Brüder an Bord/Vergleich der Überlebensrate nach Anzahl der Ehepartner
sns.barplot(x="SibSp", y="Survived", data=train, palette='Set3')

#Eltern an Bord/Vergleich der Überlebensrate nach Anzahl der Kinder
sns.barplot(x="Parch", y="Survived", data=train, palette='Set3')

#Anzahl der Familien an Bord
dataset['FamilySize']=dataset['SibSp']+dataset['Parch']+1
sns.barplot(x="FamilySize", y="Survived", data=dataset, palette='Set3')

#Gruppierung nach Überlebensrate nach Anzahl der Familien
def Family_label(s):
    if (s >= 2) & (s <= 4):
        return 2
    elif ((s > 4) & (s <= 7)) | (s == 1):
        return 1
    elif (s > 7):
        return 0
dataset['FamilyLabel']=dataset['FamilySize'].apply(Family_label)
sns.barplot(x="FamilyLabel", y="Survived", data=dataset, palette='Set3')

Ich konnte es in schöne Unterschiede aufteilen.

5. Anpassung der Überlebensrate im Nachnamen

Im obigen "Geschwister" und "Archiv" ist die familiäre Beziehung nach der dritten Klasse unbekannt, daher werden wir die Überlebensrate im Nachnamen anstelle der Familie untersuchen. Sie können einen großen Unterschied in der Überlebensrate im Nachnamen sehen.

#Untersuchen Sie die Eigenschaften des Nachnamens
dataset['Surname'] = dataset['Name'].apply(lambda x:x.split(',')[0].strip()) #Familienname, Nachname(Vom Namen","Extrahieren Sie das Wort vor)
Surname_Count = dict(dataset['Surname'].value_counts()) #Zählen Sie die Anzahl der Nachnamen
dataset['Surname_Count'] = dataset['Surname'].apply(lambda x:Surname_Count[x]) #Ersetzen Sie die Nummer des Nachnamens

#Teilen Sie Personen mit doppeltem Nachnamen in eine Gruppe von Frauen und Kindern sowie eine Gruppe von Erwachsenen und Männern ein.
Female_Child_Group=dataset.loc[(dataset['Surname_Count']>=2) & ((dataset['Age']<=12) | (dataset['Sex']=='female'))]
Male_Adult_Group=dataset.loc[(dataset['Surname_Count']>=2) & (dataset['Age']>12) & (dataset['Sex']=='male')]

#Vergleichen Sie die durchschnittliche Anzahl der Überlebensraten für jeden Nachnamen in einer Gruppe von Frauen und Kindern
Female_Child_mean = Female_Child_Group.groupby('Surname')['Survived'].mean() #Durchschnittliche Überlebensrate für jeden Nachnamen
Female_Child_mean_count = pd.DataFrame(Female_Child_mean.value_counts()) #Durchschnittliche Anzahl der Überlebensraten pro Nachname
Female_Child_mean_count.columns=['GroupCount']
Female_Child_mean_count

#Vergleichen Sie die durchschnittliche Anzahl der Überlebensraten für jeden Nachnamen in der männlichen (erwachsenen) Gruppe
Male_Adult_mean = Male_Adult_Group.groupby('Surname')['Survived'].mean() #Durchschnittliche Überlebensrate für jeden Nachnamen
Male_Adult_mean_count = pd.DataFrame(Male_Adult_mean.value_counts()) #Durchschnittliche Anzahl der Überlebensraten pro Nachname
Male_Adult_mean_count.columns=['GroupCount']
Male_Adult_mean_count

Beide Gruppen sind normalerweise 1 oder 0, was darauf hinweist, dass zwischen den Gruppen ein großer Unterschied besteht. Ist es auch eine Regel, dass jeder überleben wird (sterben), wenn der Familienname mit dem einer Familie mit Mädchen und Kindern (Erwachsene und Männer) identisch ist? Diese eindeutige Merkmalsmenge ist wertvoll. Wenn das Ergebnis, das dieser Regel entgegengesetzt ist, als Ausreißer behandelt wird, kann erwartet werden, dass es zur Verbesserung der Punktzahl beiträgt. Wir schreiben die Daten neu. Alle Personen mit demselben Nachnamen wie die Familie mit Mädchen und Kindern (Erwachsene und Männer), die jedoch alle tot sind (überleben), werden nach der entgegengesetzten Regel profiliert.

#Behandeln Sie Ausnahmen für jede Gruppe
#Extrahieren Sie die Nachnamen, die Ausnahmen für jede Gruppe sind
# Dead_Liste: Nachname, bei dem alle in einer Gruppe von Frauen und Kindern gestorben sind
# Survived_Liste: Nachname, bei dem alle in der männlichen (erwachsenen) Gruppe gestorben sind
Dead_List = set(Female_Child_mean[Female_Child_mean.apply(lambda x:x==0)].index)
print("Dead_List", Dead_List, sep="\n")
Survived_List = set(Male_Adult_mean[Male_Adult_mean.apply(lambda x:x==1)].index)
print("Survived_List", Survived_List, sep="\n")

Dead_List {'Danbom', 'Turpin', 'Zabour', 'Bourke', 'Olsson', 'Goodwin', 'Cacic', 'Robins', 'Canavan', 'Lobb', 'Palsson', 'Ilmakangas', 'Oreskovic', 'Lefebre', 'Sage', 'Johnston', 'Arnold-Franchi', 'Skoog', 'Attalah', 'Lahtinen', 'Jussila', 'Ford', 'Vander Planke', 'Rosblom', 'Boulos', 'Rice', 'Caram', 'Strom', 'Panula', 'Barbara', 'Van Impe'} Survived_List {'Chambers', 'Beane', 'Jonsson', 'Cardeza', 'Dick', 'Bradley', 'Duff Gordon', 'Greenfield', 'Daly', 'Nakid', 'Taylor', 'Frolicher-Stehli', 'Beckwith', 'Kimball', 'Jussila', 'Frauenthal', 'Harder', 'Bishop', 'Goldenberg', 'McCoy'}

#Schreiben Sie die Testdaten neu
#Zerlegen Sie Daten in Zug und Test
train = dataset.loc[dataset['Survived'].notnull()]
test = dataset.loc[dataset['Survived'].isnull()]

#Eine Person mit einem Nachnamen, die in einer Gruppe von Frauen und Kindern gestorben ist → Ein 60-jähriger Mann, dessen Titel Herr ist.
#Eine Person mit einem Nachnamen, die alle in einer männlichen (erwachsenen) Gruppe überlebt hat → Eine 5-jährige Frau, deren Titel Miss ist.
test.loc[(test['Surname'].apply(lambda x:x in Dead_List)),'Sex'] = 'male'
test.loc[(test['Surname'].apply(lambda x:x in Dead_List)),'Age'] = 60
test.loc[(test['Surname'].apply(lambda x:x in Dead_List)),'Title'] = 'Mr'
test.loc[(test['Surname'].apply(lambda x:x in Survived_List)),'Sex'] = 'female'
test.loc[(test['Surname'].apply(lambda x:x in Survived_List)),'Age'] = 5
test.loc[(test['Surname'].apply(lambda x:x in Survived_List)),'Title'] = 'Miss'

#Daten erneut kombinieren
dataset = pd.concat([train, test])

6. Machen Sie erneut eine Vorhersage

#Extrahieren Sie die zu verwendenden Variablen
dataset6 = dataset[['Survived','Pclass','Sex','Age','Fare','Embarked','Honorifics','FamilyLabel','Deck','TicketGroup']]
#Erstellen Sie eine Dummy-Variable
dataset_dummies = pd.get_dummies(dataset6)
dataset_dummies.head(3)

#Zerlegen Sie Daten in Zug und Test
#（ 'Survived'Existiert im Zug,Nicht testen)
train_set = dataset_dummies[dataset_dummies['Survived'].notnull()]
test_set = dataset_dummies[dataset_dummies['Survived'].isnull()]
del test_set["Survived"]

#Trennen Sie Zugdaten in Variablen und korrigieren Sie die Antworten
X = train_set.as_matrix()[:, 1:] #Variablen nach Pclass
y = train_set.as_matrix()[:, 0] #Richtige Antwortdaten

#Erstellen eines Vorhersagemodells
pipe = Pipeline([('classify', RandomForestClassifier(random_state = 10, max_features = 'sqrt'))])

param_test = {'classify__n_estimators':list(range(20, 30, 1)), 
              'classify__max_depth':list(range(3, 10, 1))}
gsearch = GridSearchCV(estimator = pipe, param_grid = param_test, scoring='accuracy', cv=10)
gsearch.fit(X, y)
print(gsearch.best_params_, gsearch.best_score_)

#Vorhersage von Testdaten
predictions = gsearch.predict(test_set)

#Erstellen einer CSV-Datei für die Kaggle-Übermittlung
submission = pd.DataFrame({"PassengerId": PassengerId, "Survived": predictions.astype(np.int32)})
submission.to_csv("submission6.csv", index=False)

'classify__max_depth': 5, 'classify__n_estimators': 28} 0.8451178451178452 Die eingereichte Punktzahl betrug 0,81818.

7. Vorhersage durch Reduzierung der Anzahl der Features

Da die Anzahl der Features im Vergleich zum Vorjahr erheblich auf 26 gestiegen ist, werden unwichtige Features ausgeschlossen.

pipe = Pipeline([('select',SelectKBest(k=20)),  #Erstellen Sie ein Modell mit 20 Funktionen, die für die Vorhersage nützlich sind
               ('classify', RandomForestClassifier(random_state = 10, max_features = 'sqrt'))])

param_test = {'classify__n_estimators':list(range(20, 30, 1)), 
              'classify__max_depth':list(range(3, 10, 1))}
gsearch = GridSearchCV(estimator = pipe, param_grid = param_test, scoring='accuracy', cv=10)
gsearch.fit(X, y)
print(gsearch.best_params_, gsearch.best_score_)

{'classify__max_depth': 6, 'classify__n_estimators': 26} 0.8451178451178452

select = SelectKBest(k = 20)
clf = RandomForestClassifier(random_state = 10, warm_start = True, 
                                  n_estimators = 26,
                                  max_depth = 6, 
                                  max_features = 'sqrt')
pipeline = make_pipeline(select, clf)
pipeline.fit(X, y)

Das Vorgängermodell sowie max_depth und n_estimators haben sich geändert. Unter Verwendung dieser Informationen zu max_depth und n_estimators wird der Merkmalsbetrag erneut auf 20 eingegrenzt, um ein Vorhersagemodell zu erstellen und eine Vorhersage zu erstellen.

#Bei max_Tiefe und n_Grenzen Sie die Merkmalsmenge mithilfe von Schätzern auf 20 ein und erstellen Sie erneut ein Vorhersagemodell zur Vorhersage
select = SelectKBest(k = 20)
clf = RandomForestClassifier(random_state = 10,
                             warm_start = True, 
                             n_estimators = 26,
                             max_depth = 6, 
                             max_features = 'sqrt')
pipeline = make_pipeline(select, clf)
pipeline.fit(X, y)

cv_score = model_selection.cross_val_score(pipeline, X, y, cv= 10)
print("CV Score : Mean - %.7g | Std - %.7g " % (np.mean(cv_score), np.std(cv_score)))

#Vorhersage von Testdaten
predictions = pipeline.predict(test_set)

#Erstellen einer CSV-Datei für die Kaggle-Übermittlung
submission = pd.DataFrame({"PassengerId": PassengerId, "Survived": predictions.astype(np.int32)})
submission.to_csv("submission7.csv", index=False)

CV Score : Mean - 0.8451402 | Std - 0.03276752 Die eingereichte Punktzahl sollte jetzt 0,83732 betragen. Das Ranking ab 2019 ist 217 .. Dies entspricht den oberen 1,5%.

8. Zusammenfassung

Durch logisches Ausfüllen der fehlenden Werte, Generieren neuer Funktionen wie Titel und Umschreiben der Testdaten haben wir eine Punktzahl von 0,83732 erhalten, was den besten 1,5% der Kaggle Titanic entspricht. Es werden verschiedene Datenverarbeitungen durchgeführt, und Sie können sehen, dass die Titanic als Lernprogramm zur Datenanalyse behandelt wird.

Dies ist das Ende der Titanic. Ich hoffe, es hilft denen, die diesen Artikel gelesen haben.