L'histoire d'un technicien de haut niveau essayant de prédire la survie du Titanic

** Site auquel j'ai fait référence en faisant cette fois ** https://yolo-kiyoshi.com/2020/01/22/post-1588/ https://www.codexa.net/kaggle-titanic-beginner/ https://qiita.com/suzumi/items/8ce18bc90c942663d1e6

Pensées / biais

――Il semble difficile de survivre dans un environnement glacial. .. Les femmes et les enfants sur l'embarcation de sauvetage ont-ils bénéficié d'un traitement préférentiel?

――La personne à statut social élevé ne bénéficie-t-elle pas d'un traitement préférentiel?

Confirmation des données

Vérifier avec info () À partir d'informations (), vous pouvez voir que l'âge et la cabine sont manquants.

Que faire des valeurs manquantes?

C'est comme ça quand je résume personnellement mon expérience de l'analyse de données depuis longtemps. Comment allez-vous, les gars?

Dans ce cas, l'âge avec une carence moyenne est moyen ou médian, et Cabin est une carence importante, il n'est donc pas utilisé. .. Je voudrais dire que cela est fait d'une manière facile à comprendre par d'autres personnes, alors faisons cette partie boueuse

Carence d'âge

En ce qui concerne le manque d'âge, je pense que l'important est le nom. Parmi eux, il y a des informations précieuses comme ce qu'on appelle un titre, hommes et femmes, adultes et enfants, mariés / célibataires s'il s'agit d'une femme, statut élevé, etc.

En particulier, c'est un navire qui est susceptible d'être utilisé par des personnes dans la trentaine en moyenne. La présence d'enfants et de personnes âgées dans des positions élevées réduit la précision de l'âge

Donc, tout d'abord, je vais extraire le titre.

in: #Afficher le nom
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

Si vous regardez les données à vol d'oiseau, il y a un titre entre "," et "."

in: #Je veux extraire le titre du nom
#Test de train de fusion
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 #Définissez la colonne Survived sur NaN pour les tests
all_data = pd.concat(
    [
        train_data1,
        test_data1
    ],
    sort=False,
    axis=0 #Former dans le sens de la colonne_data1、test_Combiner les données1
).reset_index(drop=True)
#all_Extraire le titre des données+Calculer l'âge moyen
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

Cela vous donnera un âge moyen pour chaque titre

Maintenant, entrons l'âge moyen à partir des titres des données manquantes en fonction de ces données.

in:Appliquer l'âge moyen de chaque titre à la valeur manquante
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

Ceci complète la carence en âge. Mais pour une raison quelconque, la colonne a disparu Transférer à l'âge initial de all_data

del(all_data['Age']) #all_Supprimer l'âge des données
all_data['Age']=age_complement['Age']　#Créez une colonne Âge et mettez-y les données d'âge de la personne qui a complété la zone manquante

Ceci termine le traitement des valeurs manquantes dans les données d'âge.

Variations tarifaires qui m'inquiétaient lors de la manipulation des données

En regardant les données, j'étais inquiet de la variation du prix du tarif, donc ce n'est pas le prix par personne, mais le montant total du groupe est substitué,? J'ai pensé. Tarif / Je compterai le nombre de billets en double et je le retournerai au prix raisonnable par personne

in:# 1.Créer un tableau de type dictionnaire qui représente le nombre de tickets en double
double_check_dict = all_data['Ticket'].value_counts().to_dict()

# 2.Ajouter plusieurs colonnes à un DataFrame
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 est le nombre de billets en double, mais après tout, le prix du tarif monte en flèche là où il y a beaucoup de billets, donc divisez le tarif par le nombre de billets.

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

Avec cela, nous avons pu supprimer les variations de prix.

** Si les chambres Cabin sont désormais stratifiées par prix, pourquoi ne pas obtenir la plupart des chambres à partir de Fare? Je pense **

Pensez à la cabine

Nous décomposerons les données contenant les données Cabin.

• Extraire l'acronyme de Cabin data et le décomposer en A, B, C, D ..
• Le groupe qui reste dans plusieurs chambres est séparé de "C12 C13 C14" dans des unités vides, alors calculez le nombre de chambres que vous avez louées avec "blank +1".

in:
cabin_data=all_data.dropna() #Extraire uniquement ceux avec des données de cabine
cabin_data['Cabin_id'] = cabin_data['Cabin'].map(lambda x:x[0]) #Cabin_Mettez l'acronyme Cabin dans id
cabin_data['room']=cabin_data['Cabin'].map(lambda x:x.count(' '))+1
cabin_data.head(50)　

Demandez-vous si vous pouvez calculer le prix de la chambre séparément pour chaque classe P

Pour voir s'il y a une différence de prix dans le classement de chaque chambre, faites un tout, divisé par P_class 1 2 3 et pensez au prix de chaque chambre

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

Cliquez ici pour le prix global

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

Cela ressemble à ceci quand vous le regardez grossièrement, mais par exemple, si les frais d'utilisation sont différents pour chaque pièce dans la même bande de classe, il est possible d'estimer la valeur manquante de Cabin, mais c'est presque la même et il semble qu'elle ne puisse pas être estimée exactement. Hmm, désolé

Obtenez le nombre de membres de la famille de SibSp et Parch

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

Divisez le tarif en 11

Je l'ai divisé en 11 parties, mais j'ai l'impression que je peux encore creuser profondément ici.

#Tarif partagé
all_data['Fare_bin'] = pd.qcut(all_data.Fare, 11)#Tarif à tarif_Divisez en 11 comme bac

Diviser le sexe

sex_col = ['Sex']
le = LabelEncoder()
for col in sex_col:
    all_data[col] = le.fit_transform(all_data[col]) #Diviser Sex male famale en 0 et 1

Remplacez'Pclass ',' Embarked ',' honororific ',' Fare_bin ',' famiry_size ', par des variables catégorielles

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'Est transformé en une variable fictive avec 0 et 1

C'est tout pour diviser chaque colonne.

Divisez all_data en données de train et de test

from sklearn.model_selection import train_test_split
 
train = all_data.query('train_or_test == "train"')#'train_or_extrait de test train
test = all_data.query('train_or_test == "test"')
#Définissez des variables cibles et des colonnes inutiles pour la formation
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',]
#Contient uniquement les fonctionnalités requises pour l'apprentissage
train_feature = train.drop(columns=drop_col)
test_feature = test.drop(columns=drop_col)
train_tagert = train[target_col]
#Données de train fractionnées
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)

Apprentissage

En tant que bibliothèque RandomForestClassifier SVC LogisticRegression CatBoostClassifier Utilisation

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)}')

Comme l'extérieur

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

Ajuster les hyperparamètres avec les tests Oputuna et Kfold

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 /Évaluez le modèle avec précision
    kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
    scores = cross_validate(model, X=X_train, y=y_train, cv=kf)
    #1 car il est minimisé.Soustrayez le score de 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 /Évaluez le modèle avec précision
    kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
    scores = cross_validate(model, X=X_train, y=y_train, cv=kf)
    #1 car il est minimisé.Soustrayez le score de 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 /Évaluez le modèle avec précision
    kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
    scores = cross_validate(model, X=X_train, y=y_train, cv=kf)
    #1 car il est minimisé.Soustrayez le score de 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):
    #Séparez les données d'entraînement et les données de test
    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)

    #Spécification des paramètres
    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)
    }

    #Apprentissage
    model = CatBoostClassifier(**params)
    # 5-Fold CV /Évaluez le modèle avec précision
    kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
    scores = cross_validate(model, X=X_train, y=y_train, cv=kf)

    #1 car il est minimisé.Soustrayez le score de 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)

Vérifiez à nouveau la précision avec le paramètre ajusté

# 5-Fold CV /Évaluez le modèle avec précision
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()}')

Par conséquent

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

est devenu. LogisticRegression est le plus précis, mais il a également une valeur std élevée.

# 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)


#Prédire chacun
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)
}


#Sortie de fichier
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)

résultat

Lorsqu'il a été soumis à Kaggle, SVC a donné les meilleurs résultats.

Après cela, j'ai ajusté diverses colonnes et hyper paramètres, mais actuellement, ce score est le résultat le plus élevé. Je pense que cela changera en fonction de la façon d'appliquer le prétraitement, donc si vous trouvez une bonne méthode à l'avenir, nous la vérifierons tout en la faisant fonctionner.