Titanicでつまづいても大丈夫！超初心者向けKaggle攻略法をご紹介

Kaggle始めてみたけどTitanicの時点でよくわからない！

Kaggleに登録してTitanicでのチュートリアルを見たものの何をやってるかよくわからない方もいますよね。

また、Titanicがある程度できるようになっても他の分析の時どう活かしていければいいかわかりづらいのも事実。

そこで今回はKaggleでTitanicに取り組むレベルの人でもKaggleでどのようなステップを踏めばいいかを解説していきます。

この記事ではTitanicではなくPythonのライブラリで入っているアヤメのデータセットを使用し品種を分類していきます。

それではまず、必要なライブラリとデータをインポートするところからお伝えしていきます。

#必要なライブラリとデータをインポート

KaggleでTitanicをやる場合もその先の問題に取り組む場合もまずは必要な道具を揃えていく必要があります。

これを行わないとせっかくコードを書いてもエラーが出てしまうので注意が必要です。

```python
import numpy as np
import pandas as pd
from pandas import DataFrame, Series
#numpyは計算、pandasはデータの加工で使用。

from sklearn.datasets import load_iris
#もともとあるデータを拝借
from sklearn import datasets
#データをpandasで使えるようにする
from sklearn.model_selection import train_test_split
#データを分割するのに使う
from sklearn.linear_model import LogisticRegression
#機械学習で今回はこれを使う

import matplotlib.pyplot as plt
import seaborn as sns
#どちらも図にするのに使う
```

ここで各ライブラリがどう使われているか触れていきます。

numpyはデータの計算、pandasは読み込んだデータの加工に使われます。

sklearnには自由に使えるデータセットが入っていたり機械学習の手法などが揃えられています。

ここではアヤメの特徴と品種名が記載されたデータを読み込んでいます。

また、そのデータをpandasで使えるようにするものやデータを分割するのに必要なものも読み込んでいます。

データの分割については後程説明していきます。

matplotlibやseabornは与えられたデータを図表にし可視化させるために使われています。

データを眺めるだけではわからないことや次の作戦を考えるヒントになることもあります。

##データの全体像を見て欠損値がないか確かめる

ライブラリを読み込んだので今回使うアヤメのデータを見ていきましょう。

```python
iris = load_iris()#アヤメのデータを読み込み
df = pd.DataFrame(iris.data, columns=iris.feature_names)#データをデータフレームで見られるようにする

df.head()#データの冒頭だけ見る
df.describe()#データの全体像を見る
```

####データの冒頭
|	|sepal length (cm)	|sepal width (cm)|petal length (cm)|petal width (cm)|
|:-----------|:-----------|:-----------|:-----------|:-----------|
|0	|5.1	|3.5	|1.4	|0.2|
|1	|4.9	|3.0	|1.4	|0.2|
|2	|4.7	|3.2	|1.3	|0.2|
|3	|4.6	|3.1	|1.5	|0.2|
|4	|5.0	|3.6	|1.4	|0.2|

####データの全体像
|	|sepal length (cm)	|sepal width (cm)|petal length (cm)|petal width (cm)|
|:-----------|:-----------|:-----------|:-----------|:-----------|
|count	|150.000000	|150.000000	|150.000000	|150.000000|
|mean	|5.843333	|3.057333	|3.758000	|1.199333|
|std	|0.828066	|0.435866	|1.765298	|0.762238|
|min	|4.300000	|2.000000	|1.000000	|0.100000|
|25%	|5.100000	|2.800000	|1.600000	|0.300000|
|50%	|5.800000	|3.000000	|4.350000	|1.300000|
|75%	|6.400000	|3.300000	|5.100000	|1.800000|
|max	|7.900000	|4.400000	|6.900000	|2.500000|

データを読み込み冒頭部分と概観を出してみました。

ここで書かれているSepal Lengthはがく片の長さ、Sepal Widthはがく片の幅、Petal Lengthは花びらの長さ、Petal Widthは花びらの幅になります。

ここにある情報がアヤメの品種を特徴づけるものであり「特徴量」と言います。

このデータは全部で150のデータがあり品種は三種類あります。

しかしここではより簡単にするため二種類に絞っていきます。

```python
df = df[:100]
```

ここから「欠損値」といいデータに抜けているところがないか見ていきます。

ここで何か勉強の参考書をイメージしてみましょう。

私達は参考書を見ている時何か誤植やよく見えない箇所があってもなんとなく頭の中で補って理解することはできます。

しかしプログラムは入力された情報を「そのまま認識する」のでエラーが表示されてしまいます。

そのため最初の段階でそれがないか確認しておく必要があるのです。

```python
df.isnull().sum()

sepal length (cm)    0
sepal width (cm)     0
petal length (cm)    0
petal width (cm)     0
dtype: int64
```

幸いここでは欠損値はありませんでした。

万が一あった場合平均値など数字を埋めたり抜けのあるところを除外するなど何かしらの処理が必要となるので覚えておきましょう。

##データを分割し学習できる状態に整える

データを読み込み欠損値がないことが確認できたのでまずはデータの分割に入っていきます。

```python
y = pd.Series(data=iris.target)
y = y[:100]
#yはアヤメの品種名になっているので数字に変換。
x = df.loc[:,["sepal length (cm)","sepal width (cm)","petal length (cm)","petal width (cm)"]]
```

```python
x_train, x_test, y_train, y_test =train_test_split(x, y, test_size = 0.1, train_size = 0.9, shuffle = True)
```

今回は読み込んだデータからランダムに1割をテスト用として分割し取り出しました。

普段のコンペであれば訓練用データとして参考書が丸々渡され、テスト用データとして試験問題が配布されます。

しかし今回はそれがないのでデータからランダムに取り出した1割を試験問題とします。

```python
x_Train, x_valid, y_Train, y_valid =train_test_split(x_train, y_train, test_size = 0.2, train_size = 0.8, shuffle = True)
```

そして残ったデータからさらにランダムに2割を取り出し演習問題とします。

ここでAIに学習をさせますがあえて最後まで取り出されなかったデータのみを使います。

どうして学習用のデータをまたさらに分割するか疑問に思う人もいますよね。

それは最後まで残った部分と演習問題で出来に差が出ていないか確認するためです。

私達が学校でテスト勉強していた頃参考書などを丸暗記したもののなかなか点に繋がらなかったこともありましたよね。

プログラム上でもそういったことが起こる場合があり「過学習」と言います。

それが起きてないか確認するために最後まで残ったページで学習をし残ったページのためだけの勉強に終始してないか演習問題を通して確認するのです。

もしそれが起きていた場合学習の仕方など見直しをする必要があります。

##学習させた結果を確かめる

```python
lg = LogisticRegression()
lg.fit(x_Train, y_Train)

LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
                   intercept_scaling=1, l1_ratio=None, max_iter=100,
                   multi_class='warn', n_jobs=None, penalty='l2',
                   random_state=None, solver='warn', tol=0.0001, verbose=0,
                   warm_start=False)
```

最後まで残った部分のみを使ってAI(人工知能)に使われる手法の一つを用いて学習させています。

学習させたものに再度学習に用いたデータと演習用に取り出したデータを使って正答率を比較します。

```python
print('Train Score: {}'.format(round(lg.score(x_Train, y_Train), 3)))
print(' Test Score: {}'.format(round(lg.score(x_valid, y_valid), 3)))

Train Score: 1.0
 Test Score: 1.0
```

検証したところほぼ問題はないようでした。

それでは学習させたものでテスト本番に臨みます。ここでは回答を作っています。

```python
y_pred = lg.predict(x_test)

y_pred
array([1, 1, 0, 0, 1, 0, 0, 0, 1, 0])

y_test
68    1
88    1
35    0
20    0
95    1
7     0
12    0
0     0
76    1
44    0
dtype: int64
```

そして正答率の確認に入ります。

```python
np.mean(y_pred==y_test)

1.0
```
自動で採点してもらったところほぼ問題ありませんでした。

普段のコンペでは答えは運営側が持っています。また、一部のデータでしか採点してくれないので注意が必要です。

## KaggleでTitanicに取り組む時はこんなこともする！

```python
sns.heatmap(df.corr(),annot=True,cmap='bwr',linewidths=0.2) 
fig=plt.gcf()
fig.set_size_inches(5,4)
plt.show()
```
![Kaggle_Titanic.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/618104/e75df894-1905-8e23-6b4f-c8caf592bd65.png)

ここでは特徴量同士でどれくらい関連性があるか表示しています。

今回はやりませんでしたが複数のものを組み合わせ新しいものを作る可能性もあります。

またAI(人工知能)に使われる手法は多岐に渡ります。

```python
from sklearn.neural_network import MLPClassifier

mlpc = MLPClassifier(hidden_layer_sizes=(100, 100, 10), random_state=0)
mlpc.fit(x_Train, y_Train)

print('Train Score: {}'.format(round(mlpc.score(x_Train, y_Train), 3)))
print(' Test Score: {}'.format(round(mlpc.score(x_valid, y_valid), 3)))

Train Score: 1.0
 Test Score: 1.0
```

```python
lg_pred = lg.predict_proba(x_test)
mlpc_pred = mlpc.predict_proba(x_test)

pred_proba = (lg_pred + mlpc_pred) / 2
pred = pred_proba.argmax(axis=1)
```
学習のやり方はそれぞれメリットデメリットがあります。

そこで複数の学習を組み合わせ精度を上げることを「アンサンブル学習」といいます。

```python
np.mean(pred==y_test)

1.0
```

今回はKaggleを始めたばかりでTitanicの分析に取り組むレベルの人でもKaggleで最低限必要な段取りがわかるようTitanicではなくアヤメのデータセットを用いて解説してきました。

最低限必要なことは必要なライブラリやデータを読み込むこと、データの全体像を見て欠損値がないか確認すること、データを分割し学習できる状態にすること、最後に学習をさせ正確さを確かめることです。

KaggleでTitanicなど本格的な分析に入ると特徴量同士の関係を見たり学習方法を複数使うなどの工夫が必要となります。

また、KaggleにはTitanicの他にも初心者向けのデータセットがあったりわからないことをディスカッションする環境も整えられています。

Kaggleのhello worldと言われるTitanicですが焦らず着実に進めながら様々なデータ分析ができるよう取り組んでいきましょう。

最後に今回使用したコードをまとめて記載します。

## 今回のコード

```python
import numpy as np
import pandas as pd
from pandas import DataFrame, Series
#numpyは計算、pandasはデータの加工で使用。

from sklearn.datasets import load_iris
#もともとあるデータを拝借
from sklearn import datasets
#データをpandasで使えるようにする
from sklearn.model_selection import train_test_split
#データを分割するのに使う
from sklearn.linear_model import LogisticRegression
#機械学習で今回はこれを使う

import matplotlib.pyplot as plt
import seaborn as sns
#どちらも図にするのに使う

iris = load_iris()#アヤメのデータを読み込み
df = pd.DataFrame(iris.data, columns=iris.feature_names)#データをデータフレームで見られるようにする
df.head()#データの冒頭だけ見る
df.describe()#データの全体像を見る
df = df[:100]#アヤメの種類を二種類のみに絞り込む
df.isnull().sum()#欠損値がないか可視化

y = pd.Series(data=iris.target)
y = y[:100]
#yはアヤメの品種名になっているので数字に変換。
x = df.loc[:,["sepal length (cm)","sepal width (cm)","petal length (cm)","petal width (cm)"]]
x_train, x_test, y_train, y_test =train_test_split(x, y, test_size = 0.1, train_size = 0.9, shuffle = True)
x_Train, x_valid, y_Train, y_valid =train_test_split(x_train, y_train, test_size = 0.2, train_size = 0.8, shuffle = True)
#データを訓練用とテスト用データに分割、訓練用データをさらに学習用と演習用に分割

lg = LogisticRegression()
lg.fit(x_Train, y_Train)

print('Train Score: {}'.format(round(lg.score(x_Train, y_Train), 3)))
print(' Test Score: {}'.format(round(lg.score(x_valid, y_valid), 3)))
#AI(人工知能)に使われる手法の一つを用いて過学習が起きてないか確認

y_pred = lg.predict(x_test)
y_pred
y_test
np.mean(y_pred==y_test)
#学習させたものでテスト用データの検証をさせ正答率を確認

sns.heatmap(df.corr(),annot=True,cmap='bwr',linewidths=0.2) 
fig=plt.gcf()
fig.set_size_inches(5,4)
plt.show()
#各特徴量の関係性を可視化

from sklearn.neural_network import MLPClassifier

mlpc = MLPClassifier(hidden_layer_sizes=(100, 100, 10), random_state=0)
mlpc.fit(x_Train, y_Train)

print('Train Score: {}'.format(round(mlpc.score(x_Train, y_Train), 3)))
print(' Test Score: {}'.format(round(mlpc.score(x_valid, y_valid), 3)))

lg_pred = lg.predict_proba(x_test)
mlpc_pred = mlpc.predict_proba(x_test)

pred_proba = (lg_pred + mlpc_pred) / 2
pred = pred_proba.argmax(axis=1)
np.mean(pred==y_test)
#アンサンブル学習といいAI(人工知能)に使われる手法をいくつか組み合わせる
```