Kaggle(37) - タイタニックをRandom Forestで予測 - チケットの重複数をパラメータ化

「同一のチケット番号だと一緒に旅行していることの指標となり、チケットの重複数と生存率には関係がある」という記事を見かけました。

今回はチケットの重複数をパラメータ化してタイタニックの生存予測を行います。

チケットの重複数をチェック

チケットの重複数をTicketFrequency項目として追加、重複数ごとに平均生存率を表示します。

[ソース]

1
2
3
4
5
6
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

df_train['TicketFrequency'] = df_train.groupby('Ticket')['Ticket'].transform('count')
df_train[['TicketFrequency', 'Survived']].groupby('TicketFrequency').mean()

[出力]

次にチケットの重複数ごとの平均生存率をグラフ化します。

[ソース]

1
df_train[['TicketFrequency', 'Survived']].groupby('TicketFrequency').mean().plot(kind='bar', figsize=(10,6))

[出力]

チケット重複が２から３の場合は、生存率が高いように見受けられます。

データの読み込みとデータクレンジング改善６

Kaggleに準備されているタイタニックの訓練データを読み込みます。

データの前処理（不要列の削除・欠損処理・カテゴリ変数の変換）と、正解ラベルとそれ以外にデータを分けます。

データクレンジングの改善６として、チケットの重複数をパラメータとして追加しています。（8行目）

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

# データ前処理
def preprocessing(df):
    df['Deck'] = df['Cabin'].apply(lambda s:s[0] if pd.notnull(s) else 'M')  # 改善２
    df['TicketFrequency'] = df.groupby('Ticket')['Ticket'].transform('count')  # 改善６

    # 不要な列の削除
    df.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)

    # 欠損値処理
    df['Age'] = df.groupby(['Pclass', 'Sex'])['Age'].apply(lambda x: x.fillna(x.median()))  # 改善１
    df['Fare'] = df['Fare'].fillna(df['Fare'].median())
    df['Embarked'] = df['Embarked'].fillna('S')

    df['Fare'] = pd.qcut(df['Fare'], 10, labels=False)   # 改善３
    df['Age'] = pd.cut(df['Age'], 10, labels=False)     # 改善４

    # カテゴリ変数の変換
    df = pd.get_dummies(df, columns=['Sex', 'Embarked', 'Deck'])  # 改善２
    
    return df

x_titanic = preprocessing(df_train.drop(['Survived'], axis=1))
y_titanic = df_train['Survived']
# x_titanic.isnull().sum()

x_titanic

[出力]

チケットの重複数としてTicketFrequencyが追加されていることが確認できます。

Random Forest分割交差検証

Random Forestのインスタンスを作成し、cross_val_score関数で分割交差検証を行い、どのくらいの正解率になるか調べてみます。

実行するたびに微妙に正解率が違うことに気づいたので、５回ほど連続実行しています。

[ソース]

1
2
3
4
5
6
7
from sklearn import ensemble, model_selection
clf = ensemble.RandomForestClassifier()

for _ in range(5):
    score = model_selection.cross_val_score(clf, x_titanic, y_titanic, cv=4) # cv=4は4分割の意
    print('各正解率', score)
    print('正解率', score.mean())

[出力]

正解率は78%～80%となりました。

Kaggleに提出

訓練データ全体で学習を行います。

その後、検証データを読み込み、推論・提出用のCSVの出力を行い、Kaggleに提出します。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
# 学習
clf.fit(x_titanic, y_titanic)

# 検証データの読み込み
df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
df_test = preprocessing(df_test)
df_test['Deck_T'] = 0

pre = clf.predict(df_test)

result = pd.DataFrame(df_test['PassengerId'])
result['Survived'] = pre
result.to_csv('result0315.csv', index=False)

[提出結果]

正解率76.55%となりました。正解率あげるのってホントに難しいんですね。

パラメータの追加・削除だけではなくて他の切り口でいく必要があると感じ始めています。

Kaggle(36) - タイタニックをRandom Forestで予測 - 名前に含まれる敬称をパラメータ化

名前に含まれる敬称は社会経済的地位に関する情報となりえる可能性があるような気がします。

そこで今回は名前に含まれる敬称(Mr. Mrs. Miss.など)を抽出し、カテゴリパラメータとして追加してみます。

名前に含まれる敬称抽出

名前から敬称を抽出しTitle項目として追加しています。

同じ敬称の個数が１０に満たない場合は’etc’とひとまとめにしました。

[ソース]

1
2
3
4
5
6
# expand=True ⇒ 複数の列に分割してpandas.DataFrameとして取得
df_train['Title'] = df_train['Name'].str.split(', ', expand=True)[1].str.split('.', expand=True)[0]
title_names = df_train['Title'].value_counts() < 10
df_train['Title'] = df_train['Title'].apply(lambda x: 'etc' if title_names.loc[x] == True else x)

df_train

[出力]

名前から敬称がきちんと抽出できていることが分かります。

各敬称の個数を表示すると下記のようになります。

[ソース]

1
df_train.groupby('Title')['Title'].count()

[出力]

メジャーな敬称が問題なく抽出されていると思います。

データの読み込みとデータクレンジング改善５

Kaggleに準備されているタイタニックの訓練データを読み込みます。

データの前処理（不要列の削除・欠損処理・カテゴリ変数の変換）と、正解ラベルとそれ以外にデータを分けます。

データクレンジングの改善５として、名前から敬称を抽出しカテゴリパラメータとしています。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

# データ前処理
def preprocessing(df):
    df['Deck'] = df['Cabin'].apply(lambda s:s[0] if pd.notnull(s) else 'M')  # 改善２

    df['Title'] = df['Name'].str.split(', ', expand=True)[1].str.split('.', expand=True)[0] # 改善５
    title_names = df['Title'].value_counts() < 10                                           # 改善５
    df['Title'] = df['Title'].apply(lambda x: 'etc' if title_names.loc[x] == True else x)   # 改善５

    # 不要な列の削除
    df.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)

    # 欠損値処理
    df['Age'] = df.groupby(['Pclass', 'Sex'])['Age'].apply(lambda x: x.fillna(x.median()))  # 改善１
    df['Fare'] = df['Fare'].fillna(df['Fare'].median())
    df['Embarked'] = df['Embarked'].fillna('S')

    df['Fare'] = pd.qcut(df['Fare'], 10, labels=False)   # 改善３
    df['Age'] = pd.cut(df['Age'], 10, labels=False)      # 改善４

    # カテゴリ変数の変換
    df = pd.get_dummies(df, columns=['Sex', 'Embarked', 'Deck', 'Title'])  # 改善２、５
    
    return df

x_titanic = preprocessing(df_train.drop(['Survived'], axis=1))
y_titanic = df_train['Survived']

Random Forest分割交差検証

Random Forestのインスタンスを作成し、cross_val_score関数で分割交差検証を行い、どのくらいの正解率になるか調べてみます。

[ソース]

1
2
3
4
5
6
7
8
from sklearn import ensemble, model_selection

clf = ensemble.RandomForestClassifier()

score = model_selection.cross_val_score(clf, x_titanic, y_titanic, cv=4) # cv=4は4分割の意
print('各正解率', score)
print('正解率', score.mean())

[出力]

正解率は80.25%となりました。

Kaggleに提出

訓練データ全体で学習を行います。

その後、検証データを読み込み、推論・提出用のCSVの出力を行い、Kaggleに提出します。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 学習
clf.fit(x_titanic, y_titanic)

# 検証データの読み込み
df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
df_test = preprocessing(df_test)
df_test['Deck_T'] = 0

pre = clf.predict(df_test)

result = pd.DataFrame(df_test['PassengerId'])
result['Survived'] = pre
result.to_csv('result0314.csv', index=False)

[提出結果]

正解率71.53%となりました。

・・・だいぶ正解率が落ちてしまいました。敬称は生存率には影響しないのかもしれません。

Kaggle(35) - タイタニックをRandom Forestで予測 - 連続変数のビニング２

ビニングまたは離散化は、連続変数または数値変数をカテゴリカル特徴に変換するための処理です。

年齢(Age)に関してビニング処理を行ってみます。

年齢データのチェック

年齢(Age)に着目してみますと、データのばらつきが大きく外れ値が予測に悪い影響を与えている可能性があります。

年齢データのばらつきを確認するために、箱ひげ図で表示します。

[ソース]

1
2
3
4
5
6
7
8
9
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

import seaborn as sns
import matplotlib.pyplot as plt
sns.set(style='darkgrid')
plt.figure(figsize=(12, 8))
sns.boxplot(data=df_train, y='Age')

[出力]

６５歳以上のデータが外れ値と判断できるかと思います。

年齢をcut関数を使って、ビニングします。cut関数は最大値と最小値の間を等間隔で分割する関数です。

今回はビンの数が５個になるように分割し（５分割）、各範囲のデータ数を表示します。

[ソース]

1
2
df_train['Age'] = pd.cut(df_train['Age'], 5, labels=False)
df_train['Age'].value_counts()

[出力]

年齢データではなく0～4の数字になっていることが分かります。

次にビニング処理を行った年齢範囲ごとの平均生存率を棒グラフで表示してみます。

[ソース]

1
df_train.groupby('Age')['Survived'].mean().plot(kind='bar', figsize=(10,6))

[出力]

若い人年齢に部類されているほど生存率が高く、年配の人の生存率が10％以下であることが見てとれます。

データの読み込みとデータクレンジング改善４

Kaggleに準備されているタイタニックの訓練データを読み込みます。

データの前処理（不要列の削除・欠損処理・カテゴリ変数の変換）と、正解ラベルとそれ以外にデータを分けます。

データクレンジングの改善４として、年齢データをcut関数を使ってビニング処理を行っています。(18行目)

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

# データ前処理
def preprocessing(df):
    df['Deck'] = df['Cabin'].apply(lambda s:s[0] if pd.notnull(s) else 'M')  # 改善２

    # 不要な列の削除
    df.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)

    # 欠損値処理
    df['Age'] = df.groupby(['Pclass', 'Sex'])['Age'].apply(lambda x: x.fillna(x.median()))  # 改善１
    df['Fare'] = df['Fare'].fillna(df['Fare'].median())
    df['Embarked'] = df['Embarked'].fillna('S')

    df['Fare'] = pd.qcut(df['Fare'], 10, labels=False)   # 改善３
    df['Age'] = pd.cut(df['Age'], 5, labels=False)       # 改善４
    
    # カテゴリ変数の変換
    df = pd.get_dummies(df, columns=['Sex', 'Embarked', 'Deck'])  # 改善２
    
    return df

x_titanic = preprocessing(df_train.drop(['Survived'], axis=1))
y_titanic = df_train['Survived']
# x_titanic.isnull().sum()

x_titanic

[出力]

年齢(Age)が、0～4の数字に変換されていることが確認できます。

Random Forest分割交差検証

Random Forestのインスタンスを作成し、cross_val_score関数で分割交差検証を行い、どのくらいの正解率になるか調べてみます。

[ソース]

1
2
3
4
5
6
7
from sklearn import ensemble, model_selection

clf = ensemble.RandomForestClassifier()

score = model_selection.cross_val_score(clf, x_titanic, y_titanic, cv=4) # cv=4は4分割の意
print('各正解率', score)
print('正解率', score.mean())

[出力]

正解率は80.36%となりました。

Kaggleに提出

訓練データ全体で学習を行います。

その後、検証データを読み込み、推論・提出用のCSVの出力を行い、Kaggleに提出します。

[ソース]

1

[提出結果]

正解率75.11%となりました。

Kaggle(34) - タイタニックをRandom Forestで予測 - 連続変数のビニング

ビニングまたは離散化は、連続変数または数値変数をカテゴリカル特徴に変換するための処理です。

運賃(Fare)に関してビニング処理を行ってみます。

運賃データのチェック

運賃(Fare)に着目してみますと、データのばらつきが大きく外れ値が予測に悪い影響を与えている可能性があります。

運賃データのばらつきを確認するために、箱ひげ図で表示します。

[ソース]

1
2
3
4
5
6
7
8
9
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

import seaborn as sns
import matplotlib.pyplot as plt
sns.set(style='darkgrid')
plt.figure(figsize=(12, 8))
sns.boxplot(data=df_train, y='Fare')

[出力]

データのばらつきは一目瞭然で、とくに500以上のデータは外れ値の最たるものかと思われます。

運賃をqcut関数を使って、ビニングします。qcut関数は各ビン(データ範囲)に含まれる個数（要素数）が等しくなるようにビニング処理（ビン分割）する関数です。

今回はビンの数が１０個になるように指定します。（１０分割）

[ソース]

1
2
df2 = pd.qcut(df_train['Fare'], 10)
df2.value_counts()

[出力]

データが１０分割され、データ数もだいたい同じであることが分かります。

データの読み込みとデータクレンジング改善３

Kaggleに準備されているタイタニックの訓練データを読み込みます。

データの前処理（不要列の削除・欠損処理・カテゴリ変数の変換）と、正解ラベルとそれ以外にデータを分けます。

データクレンジングの改善３として、運賃データをqcut関数を使ってビニング処理を行っています。(17行目)

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

# データ前処理
def preprocessing(df):
    df['Deck'] = df['Cabin'].apply(lambda s:s[0] if pd.notnull(s) else 'M')  # 改善２

    # 不要な列の削除
    df.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)

    # 欠損値処理
    df['Age'] = df.groupby(['Pclass', 'Sex'])['Age'].apply(lambda x: x.fillna(x.median()))  # 改善１
    df['Fare'] = df['Fare'].fillna(df['Fare'].median())
    df['Embarked'] = df['Embarked'].fillna('S')

    df['Fare'] = pd.qcut(df['Fare'], 10, labels=False)  # 改善３

    # カテゴリ変数の変換
    df = pd.get_dummies(df, columns=['Sex', 'Embarked', 'Deck'])  # 改善２

    return df

x_titanic = preprocessing(df_train.drop(['Survived'], axis=1))
y_titanic = df_train['Survived']

x_titanic

[出力]

運賃(Fare)が金額ではなく、0～9の数字に変換されていることが確認できます。


Random Forest分割交差検証

Random Forestのインスタンスを作成し、cross_val_score関数で分割交差検証を行い、どのくらいの正解率になるか調べてみます。

[ソース]

1
2
3
4
5
6
7
from sklearn import ensemble, model_selection

clf = ensemble.RandomForestClassifier()

score = model_selection.cross_val_score(clf, x_titanic, y_titanic, cv=4) # cv=4は4分割の意
print('各正解率', score)
print('正解率', score.mean())

[出力]

正解率は81.82%となりそこそこの結果ではありますが、これまでの結果と比較して改善したかどうかは微妙なところです。

Kaggleに提出

訓練データ全体で学習を行います。

その後、検証データを読み込み、推論・提出用のCSVの出力を行い、Kaggleに提出します。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
# 学習
clf.fit(x_titanic, y_titanic)

# 検証データの読み込み
df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
df_test = preprocessing(df_test)
df_test['Deck_T'] = 0

pre = clf.predict(df_test)

result = pd.DataFrame(df_test['PassengerId'])
result['Survived'] = pre
result.to_csv('result0312.csv', index=False)

[提出結果]

正解率75.59%となりました。

・・・７割台での足踏みがなかなかにしんどいです。

Kaggle(33) - タイタニックをRandom Forestで予測 - データクレンジング改善編２

欠測値が多いため列ごと削除していたCabinですが、先頭のアルファベットが船の階層を表しているとの情報を見つけました。

Aが船の一番上の階層で、Gが一番下の階層とのことです。

船の階層ごとの生存率チェック

船の上の方にいる方が救命ボートまでの距離が近くて、生存率が高いはずです。

この仮説をデータをチェックして確認したいと思います。

Cabinの頭文字を取得しDeckとして新しい列を追加します。欠損値の場合はとりあえず’M’を仮設定しました。

[ソース]

1
2
3
4
5
6
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

df_train['Deck'] = df_train['Cabin'].apply(lambda s:s[0] if pd.notnull(s) else 'M')
df_train

[出力]

問題なくDeckのデータが設定されていることが確認できます。

次にDeckでグループ化して、平均生存率を棒グラフで表示します。

[ソース]

1
df_train.groupby('Deck')['Survived'].mean().plot(kind='bar', figsize=(10,6))

[出力]

上の階層ほど生存率が高く、下の階層ほど生存率が低いという結果を期待していたのですが、そういう感じの結果にはなりませんでした。

ただ、これまで欠損値として扱っていたパラメータ(Cabin)を分析パラメータとして変換できたので、この修正を踏まえてKaggleに提出しておきます。

データの読み込みとデータクレンジング改善２

Kaggleに準備されているタイタニックの訓練データを読み込みます。

データの前処理（不要列の削除・欠損処理・カテゴリ変数の変換）と、正解ラベルとそれ以外にデータを分けます。

CabinをDeckに変換する処理も追加しておきます。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

# データ前処理
def preprocessing(df):
    df['Deck'] = df['Cabin'].apply(lambda s:s[0] if pd.notnull(s) else 'M')  # 改善２

    # 不要な列の削除
    df.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)

    # 欠損値処理
    df['Age'] = df.groupby(['Pclass', 'Sex'])['Age'].apply(lambda x: x.fillna(x.median()))  # 改善１
    df['Fare'] = df['Fare'].fillna(df['Fare'].median())
    df['Embarked'] = df['Embarked'].fillna('S')

    
    # カテゴリ変数の変換
    df = pd.get_dummies(df, columns=['Sex', 'Embarked', 'Deck'])  # 改善２
    
    return df

x_titanic = preprocessing(df_train.drop(['Survived'], axis=1))
y_titanic = df_train['Survived']

Random Forestのインスタンスを作成し、cross_val_score関数で分割交差検証を行い、どのくらいの正解率になるか調べてみます。

[ソース]

1
2
3
4
5
6
from sklearn import ensemble, model_selection
clf = ensemble.RandomForestClassifier()

score = model_selection.cross_val_score(clf, x_titanic, y_titanic, cv=4) # cv=4は4分割の意
print('各正解率', score)
print('正解率', score.mean())

[出力]

81.93%という、まずまずの正解率となりました。

Kaggleに提出

訓練データ全体で学習を行います。

その後、検証データを読み込み、推論・提出用のCSVの出力を行い、Kaggleに提出します。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
# 学習
clf.fit(x_titanic, y_titanic)

# 検証データの読み込み
df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
df_test = preprocessing(df_test)
df_test['Deck_T'] = 0

pre = clf.predict(df_test)

result = pd.DataFrame(df_test['PassengerId'])
result['Survived'] = pre
result.to_csv('result0311.csv', index=False)

[提出結果]

正解率77.51%となりました。

悪くはない正解率だとは思いますが、なんとか８割以上の結果を出したいものです。

Kaggle(32) - タイタニックをRandom Forestで予測 - データクレンジング改善編１

いろいろなアルゴリズムを使ってタイタニックの生存予測を行ってきましたが、正解率が上がらなくなってきたので今回からはデータクレンジングを改善していきたいと思います。

予測アルゴリズムとしてはRandom Forestの成績が一番よかったのでこれを使います。

データの読み込みとデータクレンジング改善１

Kaggleに準備されているタイタニックの訓練データを読み込みます。

データの前処理（不要列の削除・欠損処理・カテゴリ変数の変換）と、正解ラベルとそれ以外にデータを分けます。

年齢の欠損値にはこれまで一律でデータ全体の中央値を設定してきましたが、これを改善します。

年齢の中央値は乗客クラスによって異なるという論文があり、具体的には次のような点があげられていました。

  • 社会経済的地位の高い人は平均して年配
  • 性別でみると女性の方が若い

上記を踏まえて、乗客クラスと性別にグループ分けして、それぞれの中央値を年齢の欠損値に設定します(12行目)

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

# データ前処理
def preprocessing(df):
    # 不要な列の削除
    df.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)

    # 欠損値処理
    #df['Age'] = df['Age'].fillna(df['Age'].median())
    df['Age'] = df.groupby(['Pclass', 'Sex'])['Age'].apply(lambda x: x.fillna(x.median()))  # 改善１
    df['Fare'] = df['Fare'].fillna(df['Fare'].median())
    df['Embarked'] = df['Embarked'].fillna('S')

    # カテゴリ変数の変換
    df = pd.get_dummies(df, columns=['Sex', 'Embarked'])

    return df

x_titanic = preprocessing(df_train.drop(['Survived'], axis=1))
y_titanic = df_train['Survived']

Random Forestで予測

Random Forestのインスタンスを作成し、cross_val_score関数で分割交差検証を行い、どのくらいの正解率になるか調べてみます。

[ソース]

1
2
3
4
5
from sklearn import ensemble, model_selection
clf = ensemble.RandomForestClassifier()
score = model_selection.cross_val_score(clf, x_titanic, y_titanic, cv=4) # cv=4は4分割の意
print('各正解率', score)
print('正解率', score.mean())

[出力]

81.59%という、まずまずの正解率となりました。

Kaggleに提出

訓練データ全体で学習を行います。

その後、検証データを読み込み、推論・提出用のCSVの出力を行い、Kaggleに提出します。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
# 学習
clf.fit(x_titanic, y_titanic)

# 検証データの読み込み
df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
df_test = preprocessing(df_test)

# 予測
pre = clf.predict(df_test)

result = pd.DataFrame(df_test['PassengerId'])
result['Survived'] = pre
result.to_csv('result0310.csv', index=False)

[提出結果]

正解率75.59%となりました。

・・・正解率が下がってしまったような気がしますが、あきらめず引き続きデータクレンジングの改善を行っていきます。

Kaggle(31) - タイタニックをAdaBoostで予測

AdaBoostというアルゴリズムを使って、タイタニックの生存率を予測します。

AdaBoostはアンサンブル学習のブースティングに分類されるアルゴリズムの１つです。

AdaBoostでは、難易度の高いデータを正しく分類できる弱仮説器の分類結果を重視するよう、弱仮説器に対して重みを付けます。

AdaBoostは分類精度が高いですが、学習データのノイズに影響を受けやすい傾向があります。

データの読み込み

Kaggleに準備されているタイタニックの訓練データを読み込みます。

データの前処理（不要列の削除・欠損処理・カテゴリ変数の変換）と、正解ラベルとそれ以外にデータを分けます。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

# データ前処理
def preprocessing(df):
    # 不要な列の削除
    df.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)

    # 欠損値処理
    df['Age'] = df['Age'].fillna(df['Age'].median())
    df['Fare'] = df['Fare'].fillna(df['Fare'].median())
    df['Embarked'] = df['Embarked'].fillna('S')

    # カテゴリ変数の変換
    df = pd.get_dummies(df, columns=['Sex', 'Embarked'])

    return df

x_titanic = preprocessing(df_train.drop(['Survived'], axis=1))
y_titanic = df_train['Survived']

AdaBoostで予測

AdaBoostのインスタンスを生成し、cross_val_score関数で分割交差検証を行い、どのくらいの正答率になるか調べてみます。

[ソース]

1
2
3
4
5
6
from sklearn import ensemble, model_selection

clf = ensemble.AdaBoostClassifier()
score = model_selection.cross_val_score(clf, x_titanic, y_titanic, cv=4) # cv=4は4分割の意
print('各正解率', score)
print('正解率', score.mean())

[出力]

68.23%という、これまで試してきた他のアルゴリズムよりも低めの正解率となりました。

Kaggleに提出

訓練データ全体で学習を行います。

その後、検証データを読み込み、推論・提出用のCSVの出力を行い、Kaggleに提出します。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
# 学習
clf.fit(x_titanic, y_titanic)

# 検証データの読み込み
df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
df_test = preprocessing(df_test)

# df_test.isnull().sum()
pre = clf.predict(df_test)

result = pd.DataFrame(df_test['PassengerId'])
result['Survived'] = pre
result.to_csv('result0309.csv', index=False)

[提出結果]

正解率73.68%となりました。

AdaBoostアルゴリズはノイズに弱いという話でしたが、もう少し前処理でノイズの除去をする必要があるのかもしれません。

Kaggle(30) - タイタニックをRandom Forestで予測

Random Forestというアルゴリズムを使って、タイタニックの生存率を予測します。

Random Forestはアンサンブル学習と呼ばれる学習の１つです。

アンサンブル学習は、いくつかの性能の低い分類器（弱仮説器）を組み合わせて、性能の高い１つの分類器を作る手法です。

データの読み込み

Kaggleに準備されているタイタニックの訓練データを読み込みます。

データの前処理（不要列の削除・欠損処理・カテゴリ変数の変換）と、正解ラベルとそれ以外にデータを分けるところまで一気に実行します。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

# データ前処理
def preprocessing(df):
    # 不要な列の削除
    df.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)

    # 欠損値処理
    df['Age'] = df['Age'].fillna(df['Age'].median())
    df['Fare'] = df['Fare'].fillna(df['Fare'].median())
    df['Embarked'] = df['Embarked'].fillna('S')

    # カテゴリ変数の変換
    df = pd.get_dummies(df, columns=['Sex', 'Embarked'])

    return df

x_titanic = preprocessing(df_train.drop(['Survived'], axis=1))
y_titanic = df_train['Survived']

Random Forestで予測

Random Forestのインスタンスを作成し、とても便利なcross_val_score関数で分割交差検証を行い、どのくらいの正答率になるか調べてみます。

[ソース]

1
2
3
4
5
from sklearn import ensemble, model_selection
clf = ensemble.RandomForestClassifier()
score = model_selection.cross_val_score(clf, x_titanic, y_titanic, cv=4) # cv=4は4分割の意
print('各正解率', score)
print('正解率', score.mean())

[出力]

81.14%という、まずまずの正解率となりました。

Kaggleに提出

訓練データ全体で学習を行います。

その後、検証データを読み込み、推論・提出用のCSVの出力を行い、Kaggleに提出します。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
# 学習
clf.fit(x_titanic, y_titanic)

# 検証データの読み込み
df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
df_test = preprocessing(df_test)

# df_test.isnull().sum()
pre = clf.predict(df_test)

result = pd.DataFrame(df_test['PassengerId'])
result['Survived'] = pre
result.to_csv('result0308.csv', index=False)

[提出結果]

正解率78.46%となりました。

なかなか80%の壁を超えることができません・・・。

Kaggle(29) - Optunaでハイパーパラメータ調整 - LightGBM編６

学習パラメータの調整をする場合、グリッドサーチ機能を使うとパラメータの候補をリストで指定し、そのリストの組み合わせより最も成績のよい組み合わせを調べることができました。（前回記事参照）

Optunaを使うと、パラメータの候補リストではなく、パラメータの範囲を指定して最適な組み合わせを調べることができるのでより便利です。

データの読み込み

タイタニックのデータセットを読み込み、データの前処理を行って、正解ラベルとそれ以外にデータを分割します。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

# データ前処理
def preprocessing(df):
    # 不要な列の削除
    df.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)

    # カテゴリ変数の変換
    df['Sex'] = df['Sex'].astype('category')
    df['Embarked'] = df['Embarked'].astype('category')
    
    return df

x_titanic = preprocessing(df_train.drop(['Survived'], axis=1))
y_titanic = df_train['Survived']

Optunaでハイパーパラメータ調整

Optunaで学習パラメータを最適化する場合には、目的関数の定義の定義を行い、その中で学習パラメータの種類と範囲を指定します。

返値としては、成績の良いものほど数値が低くなるようにします。今回は正解率が高いほど、低い数値が返るように定義しています。(13行目)

ハイパーパラメータの自動最適化を行うためにはoptunaのcreate_studyメソッドで最適化のセッションを作り、そのセッションのoptimizeメソッドに目的関数(objective)と試行回数(n_trials)を指定します。(20行目)

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import optuna
import lightgbm as lgb
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

# 目的関数の定義（最小値問題として定式化）
def objective(trial):
    learning_rate = trial.suggest_loguniform('learning_rate', 1e-5, 1e-1)
    num_leaves = trial.suggest_int('num_leaves', 5, 30)

    gbm = lgb.LGBMClassifier(objective='binary', learning_rate=learning_rate, num_leaves=num_leaves)
    gbm.fit(train_x, train_y)
    return 1.0 - accuracy_score(valid_y, gbm.predict(valid_x))

# 訓練データをtrainとvalidに分割
train_x, valid_x, train_y, valid_y = train_test_split(x_titanic, y_titanic, test_size=0.33, random_state=0) 

# ハイパーパラメータの自動最適化
study = optuna.create_study()
study.optimize(objective, n_trials = 100)

print('求めたハイパーパラメータ', study.best_params)
print('正答率', 1.0 - study.best_value)

[出力]

今回は、学習率(learning_rate)と木にある分岐の個数(num_leaves)の最適化を行い、各パラメータが0.08623、8という結果となりました。

正答率は84.06%と、まずまずの結果になっていると思います。

Kaggleに提出

最適化したハイパーパラメータを指定して、LightGBMのインスタンスを作成し、学習を行います。

その後、検証データを読み込み、推論・提出用のCSVの出力を行い、Kaggleに提出します。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
gbm = lgb.LGBMClassifier(objective='binary', learning_rate=0.08623, num_leaves=8)

# 学習
gbm.fit(x_titanic, y_titanic)

# 検証データの読み込み
df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
df_test = preprocessing(df_test)

pre = gbm.predict(df_test)

result = pd.DataFrame(df_test['PassengerId'])
result['Survived'] = pre
result.to_csv('result0307c.csv', index=False)

[提出結果]

正解率77.99%となりました。

これまでの結果とほぼ同じ正解率となっていて、パラメータの調整だけでは成績向上は難しいのかもしれません。

もしくは、調整するパラメータの選択がよくないのか、範囲の指定がイマイチなのか・・・壁にぶつかっているような気がします。

Kaggle(28) - パラメータをチューニングする - LightGBM編５

これまではLightGBMの初期パラメータで学習を行ってきました。

LightGBMは各種パラメータを設定することができますので、今回はそのパラメータを調整して学習・推測を行ってみます。

データの読み込み

タイタニックのデータセットを読み込み、データの前処理を行って、正解ラベルとそれ以外にデータを分割します。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import numpy as np
import pandas as pd

df_train = pd.read_csv('/kaggle/input/titanic/train.csv')

# データ前処理
def preprocessing(df):
    # 不要な列の削除
    df.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)

    # カテゴリ変数の型変換
    df['Sex'] = df['Sex'].astype('category')
    df['Embarked'] = df['Embarked'].astype('category')

    return df

x_titanic = preprocessing(df_train.drop(['Survived'], axis=1))
y_titanic = df_train['Survived']

パラメータの表示

まず、LightGBMの各種パラメータを表示します。

[ソース]

1
2
3
4
5
6
import lightgbm as lgb

# LightGBMの分類器をインスタンス化
gbm = lgb.LGBMClassifier(objective='binary')

gbm.get_params()

[出力]

グリッドサーチ

いろいろなパラメータが表示されましたが、今回はこのうち次の３パラメータに対してチューニングを行います。

  • num_leaves
    木にある分岐の個数です。大きくすると精度は上がるが過学習しやすくなります。
  • reg_alpha
    L1正則化に相当するものです。デフォルトでは 0.1 ぐらいを使うことが多いです。
    L1正則化にあたるのであまり大きな値を使用するとかなり重要な変数以外を無視するようなモデルになってしまうため、精度を求めている場合あまり大きくしないほうが良いでしょう。
  • reg_lambda
    L2 正則化に相当するものです。デフォルトでは L1 と同様に 0.1 ぐらいを指定します。
    L1と違い大きな値を設定してもその変数が使われないということはありませんので、特徴量の数が多い時や、徐々に木を大きくしたいすぐにオーバーフィットするような問題に対して大きく取ることが多いです。

params変数に候補となるパラメータのリストを指定し、グリッドサーチを使って最適パラメータを探索します。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from sklearn.model_selection import GridSearchCV

# 試行するパラメータを羅列
params = {
    'num_leaves': [3, 4, 5, 6, 7, 8, 9, 10],
    'reg_alpha': [0, 1, 2, 3, 4, 5,10, 100],
    'reg_lambda': [10, 15, 18, 20, 21, 22, 23, 25, 27, 29]
}

grid_search = GridSearchCV(gbm, param_grid=params, cv=3)
grid_search.fit(x_titanic, y_titanic)

print(grid_search.best_score_)
print(grid_search.best_params_)

[出力]

チューニングしたパラメータの性能確認

グリッドサーチでのパラメータ探索の結果、num_leaves=5、reg_alpha=0、reg_lambda=22が交差検証でのスコアがベストであることが分かりました。

デフォルトのパラメータの場合と、このパラメータを使った場合の正解率の違いを確認してみます。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from sklearn import model_selection

print('== デフォルト・パラメータの場合 ==')
gbm = lgb.LGBMClassifier(objective='binary')

score = model_selection.cross_val_score(gbm, x_titanic, y_titanic, cv=3) # cv=3は3分割の意
print('各正解率', score)
print('正解率', score.mean())

print('\n== パラメータをチューニングした場合 ==')
gbm = lgb.LGBMClassifier(objective='binary', num_leaves=5, reg_alpha=0, reg_lambda=22)
score = model_selection.cross_val_score(gbm, x_titanic, y_titanic, cv=3) # cv=3は3分割の意
print('各正解率', score)
print('正解率', score.mean())

[出力]

デフォルト・パラメータの正解率が74.41%、チューニングしたパラメータでの正解率が82.49%となっており、だいぶ正解率が向上しています。

学習・推論

チューニングしたパラメータを使って、学習・推論を行います。

[ソース]

1
2
3
4
5
6
7
8
9
10
11
12
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

# 訓練データをtrainとvalidに分割
train_x, valid_x, train_y, valid_y = train_test_split(x_titanic, y_titanic, test_size=0.33, random_state=0) 

# 学習
gbm.fit(train_x, train_y)

# 推論
pre = gbm.predict(valid_x, num_iteration=gbm.best_iteration_)
print('score', round(accuracy_score(valid_y, pre) * 100, 2))

[出力]

Kaggleに提出

検証データを読み込み、推論・提出用のCSVの出力を行い、Kaggleに提出してみます。

[ソース]

1
2
3
4
5
6
7
8
9
# 検証データの読み込み
df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
df_test = preprocessing(df_test)

pre = gbm.predict(df_test)

result = pd.DataFrame(df_test['PassengerId'])
result['Survived'] = pre
result.to_csv('result0306.csv', index=False)

[提出結果]

正解率77.51%と、チューニング前よりも成績が悪くなってしまいました。

reg_lambdaの指定リストがよくなかったような気がします。

グリッドサーチ機能は便利なのですが、最適なパラメータ候補を指定するのがなかなかに難しいです。

ハイパーパラメータを自動最適化するOptunaというツールがあるらしいので今度使ってみたいと思います。