[PYTHON] Die Geschichte eines hochrangigen Technikers, der versucht, das Überleben der Titanic vorherzusagen

** Site, auf die ich mich bei dieser Zeit bezogen habe ** https://yolo-kiyoshi.com/2020/01/22/post-1588/ https://www.codexa.net/kaggle-titanic-beginner/ https://qiita.com/suzumi/items/8ce18bc90c942663d1e6

Gedanken / Voreingenommenheit

――Es scheint schwierig zu sein, in einer kalten Umgebung zu überleben. .. Wurden Frauen und Kinder auf dem Rettungsboot bevorzugt behandelt?

―― Wird die Person mit hohem sozialen Status nicht bevorzugt behandelt?

Bestätigung der Daten

Überprüfen Sie mit info () In info () können Sie sehen, dass sowohl Age als auch Cabin fehlen.

Was tun mit fehlenden Werten?

So ist es, wenn ich meine Erfahrungen mit der Datenanalyse über einen langen Zeitraum persönlich zusammenfasse. Wie geht's Euch, Leute?

In diesem Fall ist das Alter mit mittlerem Mangel durchschnittlich oder median, und Cabin ist ein großer Mangel, daher wird es nicht verwendet. .. Ich möchte sagen, dass es von anderen Leuten auf leicht verständliche Weise gemacht wird, also lasst uns diesen Teil schlammig machen

Altersmangel

In Bezug auf den Mangel an Alter denke ich, dass das Wichtigste der Name ist. Unter ihnen sind wertvolle Informationen wie der sogenannte Titel, Männer und Frauen, Erwachsene und Kinder, verheiratet / unverheiratet, wenn es sich um eine Frau handelt, hoher Status usw.

Insbesondere ist es ein Schiff, das im Durchschnitt von Menschen in den Dreißigern benutzt wird. Die Anwesenheit von Kindern und älteren Menschen in hohen Positionen verringert die Genauigkeit des Alters

Also werde ich zuerst den Titel extrahieren.

in: #Name anzeigen
train_data['Name']

out:
0                                Braund, Mr. Owen Harris
1      Cumings, Mrs. John Bradley (Florence Briggs Th...
2                                 Heikkinen, Miss. Laina
3           Futrelle, Mrs. Jacques Heath (Lily May Peel)
4                               Allen, Mr. William Henry
                             ...                        
886                                Montvila, Rev. Juozas
887                         Graham, Miss. Margaret Edith
888             Johnston, Miss. Catherine Helen "Carrie"
889                                Behr, Mr. Karl Howell
890                                  Dooley, Mr. Patrick
Name: Name, Length: 891, dtype: object

Wenn Sie die Daten aus der Vogelperspektive betrachten, gibt es einen Titel zwischen "," und "."

in: #Ich möchte den Titel aus dem Namen extrahieren
#Zugtest zusammenführen
train_data1 = train_data.copy()
test_data1 = test_data.copy()
train_data1['train_or_test'] = 'train' 
test_data1['train_or_test'] = 'test' 
test_data1['Survived'] = np.nan #Setzen Sie die Spalte "Überlebt" zum Testen auf "NaN"
all_data = pd.concat(
    [
        train_data1,
        test_data1
    ],
    sort=False,
    axis=0 #Zug in Spaltenrichtung_data1、test_Daten kombinieren1
).reset_index(drop=True)
#all_Titel aus Daten extrahieren+Durchschnittsalter berechnen
honorific=all_data['honorific'] = all_data['Name'].map(lambda x: x.split(', ')[1].split('. ')[0])
Average_age=all_data['Age'].groupby(all_data['honorific']).agg(['count','mean','median','std'])
Average_age

Wenn Sie dies tun, erhalten Sie ein Durchschnittsalter für jeden Titel

Geben Sie nun das Durchschnittsalter aus den Titeln der fehlenden Daten basierend auf diesen Daten ein.

in:Wenden Sie das Durchschnittsalter für jeden Titel auf den fehlenden Wert an
f = lambda x: x.fillna(x.mean())
age_complement = all_data.groupby('honorific').transform(f)
age_complement.info()


out:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1309 entries, 0 to 1308
Data columns (total 7 columns):
PassengerId    1309 non-null int64
Survived       1308 non-null float64
Pclass         1309 non-null int64
Age            1309 non-null float64
SibSp          1309 non-null int64
Parch          1309 non-null int64
Fare           1309 non-null float64
dtypes: float64(3), int64(4)
memory usage: 71.7 KB

Dies vervollständigt den Altersmangel. Aber aus irgendeinem Grund verschwand die Säule Übertragen Sie auf das ursprüngliche all_data-Alter

del(all_data['Age']) #all_Alter der Daten löschen
all_data['Age']=age_complement['Age']　#Erstellen Sie eine Altersspalte und fügen Sie die Altersdaten der Person ein, die den fehlenden Bereich ergänzt hat

Damit ist die Verarbeitung fehlender Werte in den Altersdaten abgeschlossen.

Tarifvariationen, über die ich mir beim Bearbeiten von Daten Sorgen gemacht habe

Als ich mir die Daten ansah, war ich besorgt über die Variation des Tarifpreises. Dies ist also nicht der Preis pro Person, sondern der Gesamtbetrag der Gruppe wird ersetzt. Ich dachte. Tarif / Ich zähle die Anzahl der doppelten Tickets und sende sie zum angemessenen Preis pro Person zurück

in:# 1.Erstellen Sie ein Array vom Typ Wörterbuch, das die Anzahl der doppelten Tickets darstellt
double_check_dict = all_data['Ticket'].value_counts().to_dict()

# 2.Fügen Sie einem DataFrame mehrere Spalten hinzu
all_data['double_check'] = all_data['Ticket'].apply(lambda x: double_check_dict[x] if x in double_check_dict else 0)
all_data['Fare']=all_data['Fare']/all_data['double_check']
all_data

Double_check ist die Anzahl der doppelten Tickets, aber schließlich steigt der Preis für Fahrpreise, wenn es viele Tickets gibt. Teilen Sie den Tarif also durch die Anzahl der Tickets.

in:
all_data['Fare']=all_data['Fare']/all_data['double_check']
all_data

Damit konnten wir Preisschwankungen unterdrücken.

** Wenn die Kabinenzimmer jetzt nach Preis geschichtet sind, warum nicht die meisten Zimmer von Fare beziehen? Ich denke **

Denken Sie an Cabin

Wir werden die Daten, die die Kabinendaten enthalten, zerlegen.

• Extrahieren Sie das Akronym für Kabinendaten und zerlegen Sie es in A, B, C, D ..
• Die Gruppe, die in mehreren Zimmern bleibt, wird in leeren Einheiten durch "C12 C13 C14" getrennt. Berechnen Sie also, wie viele Zimmer Sie mit "Leer +1" gemietet haben.

in:
cabin_data=all_data.dropna() #Extrahieren Sie nur diejenigen mit Kabinendaten
cabin_data['Cabin_id'] = cabin_data['Cabin'].map(lambda x:x[0]) #Cabin_Geben Sie das Akronym Cabin in id ein
cabin_data['room']=cabin_data['Cabin'].map(lambda x:x.count(' '))+1
cabin_data.head(50)　

Überlegen Sie, ob Sie die Raumgebühr für jede P-Klasse separat berechnen können

Um festzustellen, ob es einen Preisunterschied im Rang jedes Zimmers gibt, machen Sie eine ganze Sache, geteilt durch P_class 1 2 3, und denken Sie über den Preis jedes Zimmers nach

cabin_data_1=cabin_data.query('Pclass == "1"')
cabin_data_2=cabin_data.query('Pclass == "2"')
cabin_data_3=cabin_data.query('Pclass == "3"')

Average_ageC=cabin_data['Fare'].groupby(cabin_data['Cabin_id']).agg(['count','mean','median','std','max','min'])
Average_ageC

Klicken Sie hier für den Gesamtpreis

Average_ageC=cabin_data_1['Fare'].groupby(cabin_data_1['Cabin_id']).agg(['count','mean','median','std','max','min'])
Average_ageC

Pclass1

Average_ageC=cabin_data_2['Fare'].groupby(cabin_data_2['Cabin_id']).agg(['count','mean','median','std','max','min'])
Average_ageC

Pclass2

Average_ageC=cabin_data_3['Fare'].groupby(cabin_data_3['Cabin_id']).agg(['count','mean','median','std','max','min'])
Average_ageC

Pclass3

Es sieht so aus, wenn Sie es grob betrachten, aber wenn zum Beispiel die Nutzungsgebühr für jedes Zimmer in demselben Klassenband unterschiedlich ist, ist es möglich, den fehlenden Wert von Cabin zu schätzen, aber es ist fast gleich und es scheint, dass es nicht genau geschätzt werden kann. Hmm, sorry

Holen Sie sich die Anzahl der Familienmitglieder von SibSp und Parch

all_data['famiry_size']=all_data['SibSp']+all_data['Parch']+1

Teilen Sie den Tarif in 11

Ich habe es in 11 Teile geteilt, aber ich habe das Gefühl, dass ich hier immer noch tief graben kann.

#Tarifaufteilung
all_data['Fare_bin'] = pd.qcut(all_data.Fare, 11)#Fahrpreis zu Fahrpreis_Teilen Sie in 11 als bin

Sex teilen

sex_col = ['Sex']
le = LabelEncoder()
for col in sex_col:
    all_data[col] = le.fit_transform(all_data[col]) #Teilen Sie Sex male famale in 0 und 1

Ersetzen Sie "Klasse", "Eingeschifft", "ehrenamtlich", "Fare_bin", "famiry_size" durch kategoriale Variablen

cat_col = ['Pclass','Embarked','honorific','Fare_bin','famiry_size',]
all_data = pd.get_dummies(all_data, drop_first=True, columns=cat_col)#'Pclass','Embarked','honorific','Fare_bin','famiry_size'Wird mit 0 und 1 zu einer Dummy-Variablen gemacht

Das ist alles zum Teilen jeder Spalte.

Teilen Sie all_data in Zug- und Testdaten

from sklearn.model_selection import train_test_split
 
train = all_data.query('train_or_test == "train"')#'train_or_Testauszüge trainieren
test = all_data.query('train_or_test == "test"')
#Definieren Sie Zielvariablen und Spalten, die für das Training nicht erforderlich sind
target_col = 'Survived'
drop_col = ['PassengerId','Survived', 'Name', 'Fare', 'Ticket', 'Cabin', 'train_or_test','Parch','SibSp','honorific_Jonkheer','honorific_Mme','honorific_Dona','honorific_Lady','honorific_Ms',]
#Enthält nur die zum Lernen erforderlichen Funktionen
train_feature = train.drop(columns=drop_col)
test_feature = test.drop(columns=drop_col)
train_tagert = train[target_col]
#Zugdaten teilen
X_train, X_test, y_train, y_test = train_test_split(
    train_feature, train_tagert, test_size=0.3, random_state=0, stratify=train_tagert)

Lernen

Als Bibliothek RandomForestClassifier SVC LogisticRegression CatBoostClassifier Verwenden

from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
from catboost import CatBoostClassifier


rfc = RandomForestClassifier(random_state=0)
rfc.fit(X_train, y_train)
print('='*20)
print('RandomForestClassifier')
print(f'accuracy of train set: {rfc.score(X_train, y_train)}')
print(f'accuracy of test set: {rfc.score(X_test, y_test)}')


lr = LogisticRegression(random_state=0)
lr.fit(X_train, y_train)
print('='*20)
print('LogisticRegression')
print(f'accuracy of train set: {lr.score(X_train, y_train)}')
print(f'accuracy of train set: {lr.score(X_test, y_test)}')

svc = SVC(random_state=0)
svc.fit(X_train, y_train)
print('='*20)
print('SVC')
print(f'accuracy of train set: {svc.score(X_train, y_train)}')
print(f'accuracy of train set: {svc.score(X_test, y_test)}')


cat = CatBoostClassifier(random_state=0)
cat.fit(X_train, y_train)
print('='*20)
print('CAT')
print(f'accuracy of train set: {cat.score(X_train, y_train)}')
print(f'accuracy of train set: {cat.score(X_test, y_test)}')

Als Außenseite

RandomForestClassifier
accuracy of train set: 0.9678972712680578
accuracy of test set: 0.8246268656716418
LogisticRegression
accuracy of train set: 0.8426966292134831
accuracy of train set: 0.832089552238806
SVC
accuracy of train set: 0.8330658105939005
accuracy of train set: 0.8134328358208955
CAT
accuracy of train set: 0.9085072231139647
accuracy of train set: 0.8507462686567164

Passen Sie die Hyperparameter mit Oputuna- und Kfold-Tests an

RandomForestClassifier

from sklearn.model_selection import StratifiedKFold, cross_validate
import optuna

cv = 10
def objective(trial):
    
    param_grid_rfc = {
        "max_depth": trial.suggest_int("max_depth", 5, 15),
        "min_samples_leaf": trial.suggest_int("min_samples_leaf", 1, 5),
        'min_samples_split': trial.suggest_int("min_samples_split", 7, 15),
        "criterion": trial.suggest_categorical("criterion", ["gini", "entropy"]),
        'max_features': trial.suggest_int("max_features", 3, 10),
        "random_state": 0
    }
 
    model = RandomForestClassifier(**param_grid_rfc)
    
    # 5-Fold CV /Bewerten Sie das Modell mit Genauigkeit
    kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
    scores = cross_validate(model, X=X_train, y=y_train, cv=kf)
    #1, weil es minimiert ist.Subtrahieren Sie die Punktzahl von 0
    return scores['test_score'].mean()
 
study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100)
print(study.best_params)
print(study.best_value)
rfc_best_param = study.best_params

SVC

import warnings
warnings.filterwarnings('ignore')

def objective(trial):
    
    param_grid_lr = {
        'C' : trial.suggest_int("C", 1, 100),
        "random_state": 0
    }

    model = LogisticRegression(**param_grid_lr)
    
    # 5-Fold CV /Bewerten Sie das Modell mit Genauigkeit
    kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
    scores = cross_validate(model, X=X_train, y=y_train, cv=kf)
    #1, weil es minimiert ist.Subtrahieren Sie die Punktzahl von 0
    return scores['test_score'].mean()

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100)
print(study.best_params)
print(study.best_value)
lr_best_param = study.best_params 

LogisticRegression

import warnings
warnings.filterwarnings('ignore')

def objective(trial):
    
    param_grid_svc = {
        'C' : trial.suggest_int("C", 50, 200),
        'gamma': trial.suggest_loguniform("gamma", 1e-4, 1.0),
        "random_state": 0,
        'kernel': 'rbf'
    }

    model = SVC(**param_grid_svc)
    
    # 5-Fold CV /Bewerten Sie das Modell mit Genauigkeit
    kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
    scores = cross_validate(model, X=X_train, y=y_train, cv=kf)
    #1, weil es minimiert ist.Subtrahieren Sie die Punktzahl von 0
    return scores['test_score'].mean()

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100)
print(study.best_params)
print(study.best_value)
svc_best_param = study.best_params

CatBoostClassifier

from sklearn.model_selection import train_test_split
from catboost import Pool
import sklearn.metrics
X = train_feature
y = test_feature
categorical_features_indices = np.where(X.dtypes != np.float)[0]
def objective(trial):
    #Trainingsdaten und Testdaten trennen
    X_train, X_test, y_train, y_test = train_test_split(
    train_feature, train_tagert, test_size=0.35, random_state=0, stratify=train_tagert)
    train_pool = Pool(X_train, y_train, cat_features=categorical_features_indices)
    test_pool = Pool(X_test,y_test, cat_features=categorical_features_indices)

    #Parameterspezifikation
    params = {
        'iterations' : trial.suggest_int('iterations', 50, 300),                         
        'depth' : trial.suggest_int('depth', 4, 10),                                       
        'learning_rate' : trial.suggest_loguniform('learning_rate', 0.01, 0.3),               
        'random_strength' :trial.suggest_int('random_strength', 0, 100),                       
        'bagging_temperature' :trial.suggest_loguniform('bagging_temperature', 0.01, 100.00), 
        'od_type': trial.suggest_categorical('od_type', ['IncToDec', 'Iter']),
        'od_wait' :trial.suggest_int('od_wait', 10, 50)
    }

    #Lernen
    model = CatBoostClassifier(**params)
    # 5-Fold CV /Bewerten Sie das Modell mit Genauigkeit
    kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
    scores = cross_validate(model, X=X_train, y=y_train, cv=kf)

    #1, weil es minimiert ist.Subtrahieren Sie die Punktzahl von 0
    return scores['test_score'].mean()

if __name__ == '__main__':
    study = optuna.create_study()
    study.optimize(objective, n_trials=5)
    cat_best_param = study.best_params
    print(study.best_value)
    print(cat_best_param)

Überprüfen Sie die Genauigkeit erneut mit dem eingestellten Parameter

# 5-Fold CV /Bewerten Sie das Modell mit Genauigkeit
kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)

rfc_best = RandomForestClassifier(**rfc_best_param)
print('RandomForestClassifier')
scores = cross_validate(rfc_best, X=train_feature, y=train_tagert, cv=kf)
print(f'mean:{scores["test_score"].mean()}, std:{scores["test_score"].std()}')

lr_best = LogisticRegression(**lr_best_param)
print('LogisticRegression')
scores = cross_validate(lr_best, X=train_feature, y=train_tagert, cv=kf)
print(f'mean:{scores["test_score"].mean()}, std:{scores["test_score"].std()}')

svc_best = SVC(**svc_best_param)
print('SVC')
scores = cross_validate(svc_best, X=train_feature, y=train_tagert, cv=kf)
print(f'mean:{scores["test_score"].mean()}, std:{scores["test_score"].std()}')

cat_best =CatBoostClassifier
print('CAT')
scores = cross_validate(cat, X=train_feature, y=train_tagert, cv=kf)
print(f'mean:{scores["test_score"].mean()}, std:{scores["test_score"].std()}')

als Ergebnis

RandomForestClassifier
mean:0.827152263628423, std:0.029935476082608138
LogisticRegression
mean:0.8294309818436642, std:0.03568888547665349
SVC
mean:0.826034945192669, std:0.03392425879847107
CAT
mean:0.8249241166088076, std:0.030217830226771592

ist geworden. LogisticRegression ist am genauesten, hat aber auch einen hohen Standardwert.

# RandomForest
rfc_best = RandomForestClassifier(**rfc_best_param)
rfc_best.fit(train_feature, train_tagert)

# LogisticRegression
lr_best = LogisticRegression(**lr_best_param)
lr_best.fit(train_feature, train_tagert)

# SVC
svc_best = SVC(**svc_best_param)
svc_best.fit(train_feature, train_tagert)

#CatBoostClassifier
cat_best = CatBoostClassifier(**cat_best_param)
cat_best.fit(train_feature, train_tagert)


#Sagen Sie jeden voraus
pred = {
    'rfc': rfc_best.predict(test_feature).astype(int),
    'lr': lr_best.predict(test_feature).astype(int),
    'svc': svc_best.predict(test_feature).astype(int),
    'cat': cat_best.predict(test_feature).astype(int)
}


#Dateiausgabe
for key, value in pred.items():
    pd.concat(
        [
            pd.DataFrame(test.PassengerId, columns=['PassengerId']).reset_index(drop=True),
            pd.DataFrame(value, columns=['Survived'])
       ],
        axis=1
    ).to_csv(f'output_{key}.csv', index=False)

Ergebnis

Bei der Übermittlung an Kaggle erzielte SVC die höchsten Ergebnisse.

Danach habe ich verschiedene Spalten und Hyperparameter angepasst, aber derzeit ist diese Punktzahl das höchste Ergebnis. Ich denke, dass sich dies je nach Anwendung der Vorverarbeitung ändern wird. Wenn Sie also in Zukunft eine gute Methode entwickeln, werden wir diese überprüfen, während Sie sie tatsächlich betreiben.