【Titanic】KaggleのTitanicを40代サラリーマンが解く！初心者にもわかりやすく

# 各モデルのインポート
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

# データの読み込み
df_train = pd.read_csv("/kaggle/input/titanic/train.csv")
df_test = pd.read_csv("/kaggle/input/titanic/test.csv")

# データの確認(shpeを使ってそれぞれのデータサイズを確認
print(f'df_train: {df_train.shape}')
print(f'df_test:  {df_test.shape}')

# データの中身を確認
df_train.head()

# 1. データ内容の確認
df_train.info()
print('_'*40)  #区切り用です
df_test.info()

# 以下が出力内容
'''
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  891 non-null    int64  
 1   Survived     891 non-null    int64  
 2   Pclass       891 non-null    int64  
 3   Name         891 non-null    object 
 4   Sex          891 non-null    object 
 5   Age          714 non-null    float64
 6   SibSp        891 non-null    int64  
 7   Parch        891 non-null    int64  
 8   Ticket       891 non-null    object 
 9   Fare         891 non-null    float64
 10  Cabin        204 non-null    object 
 11  Embarked     889 non-null    object 
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB
________________________________________
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 418 entries, 0 to 417
Data columns (total 11 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  418 non-null    int64  
 1   Pclass       418 non-null    int64  
 2   Name         418 non-null    object 
 3   Sex          418 non-null    object 
 4   Age          332 non-null    float64
 5   SibSp        418 non-null    int64  
 6   Parch        418 non-null    int64  
 7   Ticket       418 non-null    object 
 8   Fare         417 non-null    float64
 9   Cabin        91 non-null     object 
 10  Embarked     418 non-null    object 
dtypes: float64(2), int64(4), object(5)
memory usage: 36.0+ KB
'''

# 基本統計量の出力
df_train.describe()

# 出力結果は下記。見やすさのため .round(1) を上記に追加している。桁数丸め

# データセットのヒストグラムの表示
df_train.hist()
plt.tight_layout()　　　# タイトルとx軸が重なってしまうためグラフ間を広げる
plt.show()

# seabornの棒グラフを作成。paletteは色味の調整のため無くてもよい
sns.barplot(data=df_train, x='Pclass', y='Survived', palette='deep')
plt.show()

# subplotsを用いることにより、行 1 x 列 2 のグラフを作成。
# barplotの中にax[?]とすることで、グラフの位置をしている
fig, ax = plt.subplots(1,2, figsize=(12,6), sharey=True)
sns.barplot(data=df_train, x='SibSp', y='Survived', palette='deep', ax=ax[0])
sns.barplot(data=df_train, x='Parch', y='Survived', palette='deep', ax=ax[1])
plt.show()

# x軸をSexとして棒グラフを作成
sns.barplot(data=df_train, y='Survived', x='Sex', palette='deep')
plt.show()

# x軸をEmbarkedとして棒グラフを作成
sns.barplot(data=df_train, x='Embarked', y='Survived', palette='deep')
plt.show()

# 要素毎にグラフを作成するために、FacetGridを用いる。
# g.map内に左の順番に適用した、order, hue_orderを設定する (グラフの入れ替えを防ぐ)
g = sns.FacetGrid(data=df_train, col='Embarked')
g.map(sns.pointplot, 'Pclass', 'Survived', 'Sex', order=[1,2,3], hue_order=['male', 'female'] ,palette='deep')
g.add_legend()
plt.show()

# ピポットテーブルを用いてそれぞれの人数を求める
df_train.pivot_table(columns=['Embarked','Pclass','Sex'], index=['Survived'], values='PassengerId', aggfunc='count')

# 生死で層別したスタック型のヒストグラムを作成する
sns.histplot(data=df_train, x='Age', hue='Survived', multiple='stack', binwidth=3)
plt.show()

# subplotsを用いて、二つのグラフを表示。
# 左側ax[0]に通常のヒストグラム。右側ax[1]に各項目における生死の割合を示した分布(multiple='fill')
fig, ax = plt.subplots(1,2,figsize=(12,5))
sns.histplot(data=df_train, x='Fare', bins=40, ax=ax[0])
sns.histplot(data=df_train, x='Fare', hue='Survived',bins=40, multiple= "fill", palette='deep', ax=ax[1])
plt.show()

# リストにトレーニングデータとテストデータを格納
datasets = [df_train, df_test]
cols = ['Cabin', 'Name', 'Ticket']

# 各データセットに対して列の削除を行い、元のデータセットを更新する
for df in datasets:
    #inplace=True を用いる事により、元のデータセットを変えている
    df.drop(cols, axis=1, inplace=True)

# 更新されたデータセットを表示（トレーニングデータ）
display(df_train.head(3))

# 更新されたデータセットを表示（テストデータ）
display(df_test.head(3))

# ２つのデータセットの欠損値を確認するため、リストに登録してそれぞれに対してisnullを適用
datasets = [df_train, df_test]
for df in datasets:
    display(df.isnull().sum())
    print('-'*40)

# dropna()で欠損行を削除し、modeで最頻値を求める。
# モードの出力はデータフレームで返ってくるため、スライスで欲しい値を取っている
freq_port = df_train['Embarked'].dropna().mode()[0]
freq_port
# 出力： 'S'

# fillna()で欠損値をfreq_portで穴埋めする
df_train['Embarked'] = df_train['Embarked'].fillna(freq_port)
df_train['Embarked'].info()

# boxplotでPclassとFareの関係性を視覚化する
sns.boxplot(data=df_train, x='Pclass', y='Fare', palette='deep')
plt.show()

# PclassごとのFareの中央値を計算したpivot_tableの作成
median_Fare = df_train.pivot_table(index='Pclass', values='Fare', aggfunc='median')
median_Fare

# df_testだけの補完でも問題がないが、冗長的性を持たせるために両方のデータセットに適用
datasets = [df_train, df_test]
for df in datasets:
    # Fareの欠損値をPclassごとの中央値で補完
    df['Fare'] = df.apply(lambda row: median_Fare.loc[row['Pclass'],'Fare'] if pd.isnull(row['Fare']) else row['Fare'], axis=1)

# 補完が出来たかの確認
df_test.isnull().sum()

# map関数を用いてSexの文字をそれぞれの数字に変換する
datasets = [df_train, df_test]
for df in datasets:
    df['Sex'] = df['Sex'].map( {'female': 0, 'male': 1} ).astype(int)

df_train.head(3)

# ランダムフォレストをインポートする
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report

# パラメータをピックアップし、リストに代入しておく
features = ["Pclass", "Sex", "SibSp", "Parch", "Fare"]

# trainデータとtestデータを縦に連結
df_concat = pd.concat([df_train, df_test], ignore_index=True)

# 欠損値のない行をトレーニングデータとして使用
train_data = df_concat.dropna(subset=['Age'])

# データの前処理
X_train = train_data[features]
y_train = train_data['Age']

# ランダムフォレスト回帰モデルのトレーニング
rf_model = RandomForestRegressor(random_state=42)
rf_model.fit(X_train, y_train)

# モデルを用いてtrainデータのAgeを予測し補完
df_train.loc[df_train['Age'].isnull(), 'Age'] = rf_model.predict(df_train.loc[df_train['Age'].isnull(), features] )

# Testデータも同様に予測値を適用する
df_test.loc[df_test['Age'].isnull(), 'Age'] = rf_model.predict(df_test.loc[df_test['Age'].isnull(), features] )

# 元のヒストグラムと傾向性が違っていないかを確認する
df_concat_after = pd.concat([df_train, df_test], ignore_index=True)

fig, ax = plt.subplots(1,2,figsize=(12,5), sharey=True)
sns.histplot(data=df_concat, x='Age', bins=30, color='gray', stat='percent', ax=ax[0])
sns.histplot(data=df_concat_after, x='Age', bins=30, stat='percent', ax=ax[1])
plt.show()

# 特徴量の重要度を取得
importances = rf_model.feature_importances_

# 特徴量の重要度を降順にソートし、対応する特徴量名を取得
sorted_indices = np.argsort(importances)[::-1]
sorted_features = np.array(features)[sorted_indices]

# 特徴量の重要度を可視化
plt.figure(figsize=(4, 3))
plt.bar(sorted_features, importances[sorted_indices])
plt.xlabel('Features')
plt.ylabel('Importance')
plt.title('Feature Importance of Random Forest Model')
plt.xticks(rotation=45)
plt.show()

# trainデータとtestデータの両方を踏まえて、Fareを5分割にするFareBandを作る
df_concat = pd.concat([df_train, df_test], ignore_index=True)

# Fareを5つのビンに分割して境界値を取得
# pd.qcut(df_train['Fare'], 4) で Fare列の値それぞれに対して、どの区間にあるかを示す
# unique()関数を用いて分割項目を取り出し、ソートを行う
# interval (-0.001, 7.91] の項目が取得できるため、interval.right で右側の値を取得（内包表記使っている)
# 先頭の[-1]は、pd.cutの時の最小値の設定のため。0設定だと、0がNaNになってしまう
boundary_Fare = [-1] + [interval.right for interval in sorted(pd.qcut(df_concat['Fare'], 5).unique())]
boundary_Fare[-1] = boundary_Fare[-1] + 1  # pd.cutの際に最大値がNaNにならないように１をたす（小数点対策)
print(f'boundary_Fare: {boundary_Fare}')

# 各データセットをboundary_Fareを当てはめていく。pd.cutでbins毎に区間分けができる
datasets = [df_train, df_test]
for df in datasets:
    df['FareBand'] = pd.cut(df['Fare'], bins=boundary_Fare, labels=False)

df_train.head(3)

# trainデータとtestデータの両方を踏まえて、Ageを5分割にするFareBandを作る
df_concat = pd.concat([df_train, df_test], ignore_index=True)

# Ageを均等に5つに分割し境界値を取得
boundary_Age = [-1] + [interval.right for interval in sorted(pd.cut(df_concat['Age'], 5).unique())]
boundary_Age[-1] = boundary_Age[-1] + 1  # pd.cutの際に最大値がNaNにならないように１をたす（小数点対策)
print(f'boundary_Age: {boundary_Age}')

datasets = [df_train, df_test]
for df in datasets:
    df['AgeBand'] = pd.cut(df['Age'], bins=boundary_Age, labels=False)

df_train.head(3)

# trainとtestの両方に適用するために、データセットをまとめる
datasets=[df_train, df_test]

# S: 0, C: 1, Q: 2 に変換する
for df in datasets:
    df['Embarked'] = df['Embarked'].map({'S': 0, 'C': 1, 'Q': 2})
df_train.head(3)

# 特徴量の選択し、featuresに格納する
features = ['Pclass', 'Sex', 'AgeBand', 'SibSp', 'Parch', 'FareBand', 'Embarked']

# 機械学習では、trainデータを用いて精度を確認し、提出時にtestデータを用いる。
X = df_train[features]
y = df_train['Survived']

# HOLD-OUT法を用いるため、ライブラリーをインポート
from sklearn.model_selection import train_test_split

# データをトレーニング用とテスト用に分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

print(f'X_train: {X_train.shape}, X_test: {X_test.shape}')
X_train.head(5)

df_scores = pd.DataFrame(columns=['score','AUC'])

from sklearn.linear_model import LogisticRegression

# ロジスティック回帰モデルのインスタンスを作成(インスタンス名をlogregにしている）
logreg = LogisticRegression()

# トレーニングデータを用いてモデルの学習を行う
logreg.fit(X_train, y_train)

# テストデータを使って予測を行い、予測結果をY_predに格納する
y_pred = logreg.predict(X_test)

# モデルの精度（学習データに対する精度）を計算し、acc_logに格納する
acc_log = round(logreg.score(X_test, y_test) * 100, 2)
df_scores.loc['acc_log','score'] = acc_log
print(f'acc_log: {acc_log}')
#出力　acc_log: 80.06

# ROC曲線を計算
fpr, tpr, thresholds = roc_curve(y_test, y_pred)

# AUCを計算
auc = round(roc_auc_score(y_test, y_pred) * 100, 2)

# スコアのデータフレームに追加
df_scores.loc['log','AUC'] = auc

# AUCを表示
print("AUC_log:", auc) #AUC_log: 78.96

# ROC曲線をプロット
plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='b', lw=2, label='ROC curve')
plt.plot([0, 1], [0, 1], color='gray', linestyle='--', lw=2)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic (ROC) Curve')
plt.legend(loc='lower right')
plt.show()

from sklearn.tree import DecisionTreeClassifier
decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, y_train)
y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_test, y_test) * 100, 2)
df_scores.loc['acc_decision_tree','score'] = acc_decision_tree
print(f'acc_decision_tree: {acc_decision_tree}')
#出力　acc_decision_tree: 88.48

fpr, tpr, thresholds = roc_curve(y_test, y_pred)
auc = round(roc_auc_score(y_test, y_pred) * 100, 2)
df_scores.loc['decision_tree','AUC'] = auc
print("AUC_decision_tree:", auc)
#出力 AUC_decision_tree: 80.3

from sklearn.ensemble import RandomForestClassifier
random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, y_train)
y_pred = random_forest.predict(X_test)
random_forest.score(X_train, y_train)
acc_random_forest = round(random_forest.score(X_test, y_test) * 100, 2)
df_scores.loc['acc_random_forest','score'] = acc_random_forest
print(f'acc_random_forest: {acc_random_forest}')
#出力　acc_random_forest: 88.48

fpr, tpr, thresholds = roc_curve(y_test, y_pred)
auc = round(roc_auc_score(y_test, y_pred) * 100, 2)
df_scores.loc['random_forest','AUC'] = auc
print("AUC_random_forest:", auc)
#出力 AUC_random_forest: 82.8

from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_test, y_test) * 100, 2)
df_scores.loc['acc_knn','score'] = acc_knn
print(f'acc_knn: {acc_knn}')
#出力　acc_knn: 84.83

fpr, tpr, thresholds = roc_curve(y_test, y_pred)
auc = round(roc_auc_score(y_test, y_pred) * 100, 2)
df_scores.loc['knn','AUC'] = auc
print("AUC_knn:", auc)
AUC_knn: 77.79

from sklearn.svm import SVC, LinearSVC
svc = SVC()
svc.fit(X_train, y_train)
y_pred = svc.predict(X_test)
acc_svc = round(svc.score(X_test, y_test) * 100, 2)
df_scores.loc['acc_svc','score'] = acc_svc
print(f'acc_svc: {acc_svc}')
#出力　acc_svc: 82.87

fpr, tpr, thresholds = roc_curve(y_test, y_pred)
auc = round(roc_auc_score(y_test, y_pred) * 100, 2)
df_scores.loc['svc','AUC'] = auc
print("AUC_svc:", auc)
#出力 AUC_svc: 80.3

# ライブラリは上記ですでにインポート済み
linear_svc = LinearSVC(max_iter=10000) #収束せずにWarningが出たため反復回数を増やした
linear_svc.fit(X_train, y_train)
y_pred = linear_svc.predict(X_test)
acc_linear_svc = round(linear_svc.score(X_test, y_test) * 100, 2)
df_scores.loc['acc_linear_svc','score'] = acc_linear_svc
print(f'acc_linear_svc: {acc_linear_svc}')
#出力　acc_linear_svc: 79.35

fpr, tpr, thresholds = roc_curve(y_test, y_pred)
auc = round(roc_auc_score(y_test, y_pred) * 100, 2)
df_scores.loc['linear_svc','AUC'] = auc
print("AUC_linear_svc:", auc)
#出力 AUC_linear_svc: 78.19

from sklearn.linear_model import SGDClassifier
sgd = SGDClassifier()
sgd.fit(X_train, y_train)
y_pred = sgd.predict(X_test)
acc_sgd = round(sgd.score(X_test, y_test) * 100, 2)
df_scores.loc['acc_sgd','score'] = acc_sgd
print(f'acc_sgd: {acc_sgd}')
#出力　acc_sgd: 55.06

fpr, tpr, thresholds = roc_curve(y_test, y_pred)
auc = round(roc_auc_score(y_test, y_pred) * 100, 2)
df_scores.loc['sgd','AUC'] = auc
print("AUC_sdg:", auc)
#出力 AUC_sdg: 78.84

from sklearn.linear_model import Perceptron
perceptron = Perceptron()
perceptron.fit(X_train, y_train)
y_pred = perceptron.predict(X_test)
acc_perceptron = round(perceptron.score(X_test, y_test) * 100, 2)
df_scores.loc['acc_perceptron','score'] = acc_perceptron
print(f'acc_perceptron: {acc_perceptron}')
#出力　acc_perceptron: 75.98

fpr, tpr, thresholds = roc_curve(y_test, y_pred)
auc = round(roc_auc_score(y_test, y_pred) * 100, 2)
df_scores.loc['perceptron','AUC'] = auc
print("AUC_perceptron:", auc)
#出力 AUC_perceptron: 70.12

from sklearn.naive_bayes import GaussianNB
gaussian = GaussianNB()
gaussian.fit(X_train, y_train)
y_pred = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_test, y_test) * 100, 2)
df_scores.loc['acc_gaussian','score'] = acc_gaussian
print(f'acc_gaussian: {acc_gaussian}')
#出力　acc_gaussian: 77.25

fpr, tpr, thresholds = roc_curve(y_test, y_pred)
auc = round(roc_auc_score(y_test, y_pred) * 100, 2)
df_scores.loc['gaussian','AUC'] = auc
print("AUC_gaussian:", auc)
#出力 AUC_gaussian: 78.96

df_scores.sort_values(by='AUC',ascending=False)

# 特徴量の重要度を取得
importances = random_forest.feature_importances_

# 特徴量の重要度を降順にソートし、対応する特徴量名を取得(argsortでインデックス番号を取得)
sorted_indices = np.argsort(importances)[::-1]
sorted_features = np.array(features)[sorted_indices]

# 特徴量の重要度を出力 (Zipを用いることで、それぞれのリストから同時に値を取ってくる)
for imp, v in zip(sorted_features, importances[sorted_indices]):
    print(f'{imp}: {v.round(3)}')
print('-'*53)
    
# 特徴量の重要度を可視化
plt.figure(figsize=(4, 3))
plt.bar(sorted_features, importances[sorted_indices])
plt.xlabel('Features')
plt.ylabel('Importance')
plt.title('Feature Importance of Random Forest Model')
plt.xticks(rotation=45)
plt.show()

# 各特徴量をデータフレームとして表示するために、新たなデータフレームを作る
coeff_df = pd.DataFrame(index=features, columns=['Correlation'])
# ロジステック回帰モデルをモデル化した logreg の coef_[0] にリストで各要素の
coeff_df['Correlation'] = logreg.coef_[0]
coeff_df.sort_values(by='Correlation', ascending=False)

# テストデータを用いて予測を行う
y_submit = random_forest.predict(df_test[features])

# 予測結果をテストデータの新しい列 'Survived' として追加
df_test['Survived'] = y_submit

# 提出用のデータフレームを作成し、'PassengerId' と 'Survived' 列を選択
submission_df = df_test[['PassengerId', 'Survived']]

# 提出用データフレームを表示
display(submission_df)

# 提出用の CSV ファイルとして保存（インデックス列を含まないように index=False を指定）
submission_df.to_csv('submission.csv', index=False)