Kaggleについてもっと知りたい方はKaggleとは？機械学習初心者が知っておくべき3つの使い方を参考にしてみてください。

Kaggle Notebookが人気の3つの理由

ここでは、なぜKaggle Notebookなのかを、「開発環境」「環境構築」「Kaggleとの連携」の三つの理由をもとに解説していきます。

最低限の開発環境を無料で利用可能

数千、数万という比較的機械学習では少ないデータ数を扱う際や、シンプルな機械学習モデルを作る際などにはそれほどのマシンスペックは求められません。しかし機械学習の性質上、数百、数千万という膨大なデータや計算が複雑なアルゴリズムを含むモデルを作成する機会が多々あります。その際に、マシンスペックが理由で計算ができないことがあります。Kaggle NotebookではGPUやTPUの利用ができるため、より機械学習に向いた開発環境です。（GPU・TPUは後述します）

環境構築が不要

機械学習のモデルの実装のために、多くのライブラリやフレームワークが必要です。ライブラリは目的に応じて自身の環境へインストールする必要があります。環境構築は特にプログラミング初学者には複雑で手間がかかる場合があります。しかし、Kaggle Notebookでは機械学習で使わられる代表的なライブラリが利用可能な状態で提供されます。そのため初心者でも複雑な環境構築をせずに機械学習の環境が利用できるのは大きなメリットの一つです。ただし全てのライブラリ・ フレームワークがインストールされている訳ではありません。追加でインストールが必要なライブラリもあります。例えば日本語の形態素解析で使用されるライブラリ「mecab」 はKaggle Notebookにはインストールされていません。ライブラリの追加方法は後ほど詳しく解説します。

Kaggleとの連携

Kaggle NotebookはもちろんKaggleの利用に最適化された開発環境となっています。データ分析コンペに参加する際は特に便利に感じることができるでしょう。例えばデータをダウンロードをせずにコンペ用のデータセットを使用できたり、アウトプットした予測値をワンクリックで提出できます。

Kaggle Notebookの使い方(基本編)

この基本編では、Kaggle Notebookを扱う上で基礎と以下の操作方法を解説します。Kaggle Notebookを初めて扱う方は一緒に操作を行ってみてください。

• アクセスおよび起動の仕方
• セルとボタンの説明
• データの使い方
• ライブラリの追加の仕方

アクセスおよび起動の仕方

Kaggle Notebookの使用するには無料会員登録が必要です。ログイン後にKaggleトップページの左の欄の「Notebooks」をクリックするとノートブックのトップページへ遷移します。ノートブックのトップページの「+New Notebook」をクリックしてください。

図２の「Select language」で使用言語を選択することが可能です。現在はPythonとR言語の2種類の言語を選択できます。次に「Select type」でNotebookかScriptを選択してください。目的に応じてどちらの種類を使用するのかは異なります。本稿ではNotebookを解説します。

図２

「SHOW ADVANCED SETTINGS」は高度な設定のため、原則は変更は不要です。そのまま「Create」ボタンをクリックしてNotebookの作成をしましょう。「ADVANCED SETTINGS」の内容については、本記事の最後の項で解説をします。

セルとボタン説明

図3のように一つ一つのコードを入れる行をJupyter Notebookでは「セル」と呼びます。セルの中へPythonのコードを入力し、実行することができます。Notebookの最大の特徴はこのセルにあります。Notebookでは全体を一括実行だけでなく、セル単位でコードを実行することができるので、データの細かい分析やEDA（探索的データ分析）をする際など、すべてのコードを実行する必要がない場合に便利です。（図３を参照）

図３

次に左上に図4のような3つのボタンがあります。 一番左はセルを下に一つ追加、真ん中はセルを実行。一番左は、Notebook「全体のコードを実行」です。Kaggle Notebookでは便利なショートカットキーの設定が用意されています。最も頻繁に使われるショートカットキーの一つに「Shift ＋ Enter」があります。これには「選択中のセルを実行し、下にセルを追加」という機能を有している非常に便利なショートカットキーなのでぜひ使ってみてください。

図４

Notebookでの作業が終わったら必ず保存をしましょう。図5の「Save Version」 をクリックすることでノートブックの保存が可能です。注意点として、Kaggle Notebookの仕様の一つに、最後の操作から１時間経過してしまうと、ページの更新が必要になるというものがあります（windowsでのF5）。これを行った際、コードは消えませんが実行結果や出力したファイルが消えてしまうので、１時間以上、デスクの前から席を外す場合はこちらのセーブボタンで保存するようにしておきましょう。

図５

データの使い方

機械学習モデル開発の際にとても重要になるものがデータです。データなくして機械学習開発ははじまりません。そのような機械学習を勉強する際に一番大事なものと言っても過言でないデータの扱い方について、触れていきたいと思います。

最初に、Notebook右上の青字の「+ Add data」をクリックしていただくと 図６のような画面が出てくると思います。自分のデータを使いたいときは「Upload」をクリックし、自分のデータをアップロードすれば、 Kaggle Notebook上ですぐに使えるようになります。自習の際はもちろん、なにか自分の成果物を作りたいとき、さらにはコンペにて外部データを用いてより良いモデルを作りたい時に必要なデータは 「Datasets」で探すことができます。そしてKaggleのコンペで使われているデータは「Competition Data」 をクリックしコンペ名を入力すれば探すことができます。

図６

本項では試しに、有名なタイタニックコンペのファイル(train.csv)をKaggle Notebook上で使用し、読み込みまで行ってみたいと思います。

図6-1の左の青枠の「Competition Data」をクリックしていただき、右の検索欄に「Titanic」と入力していただくと、Titanicのコンペが出てきます。そしたら右の「Add」を押していただけばNotebook上でそのデータが使用可能になります。(コンペティションのデータセットはノートブックに追加しても、自分のデータセットには入れる必要がなく使用することができます。)

図6-1

次に図７の右上の矢印をクリックしていただくと、このNotebook上のディレクトリを表示することができ、Notebook上のファイル構造を確認することができます。 それを確認することで、今回はinputフォルダの中にtitanicフォルダが入っていて、 その中に目的のtrain.csvのデータがあることがわかります。

図7-1

(‘../input/titanic/train.csv’)このようなファイルパスを指定してあげることにより無事データを取り込み、出力させることができました。

図7-2

ライブラリの追加

この項に入る前に、ライブラリという言葉を少し紹介させていただきます。

プログラミングの作業をより簡単に効率的に進めるために、ライブラリというものが存在します。このライブラリとは道具箱のようなもので、この中には色々な小道具が入っています。本来この小道具たちは１からプログラムを組んで作らなければいけないのですが、このライブラリを使うことでその過程を省略し、すぐに使うことができます。

Kaggle Notebookには一般的に使われるライブラリは既にインストールしてあり、importすることによってすぐに使えるようになっていますが、一部のライブラリはインストールが必要な場合があります。本稿では、名前から人種を判別するライブラリである「Ethnicolr」を用いてライブラリの追加の方法を紹介します。

図8-1にて「ethinicolr」をimportしようとしますが、「ModuleNotFoundError:No module namese ‘ethnicolr’」と出てきます。これは、ライブラリやフレームワークがインストールされていない状態でimportをしようとすると出るエラーです。

図8-1

図8-1でこのライブラリがimportされていないことが確認できたので、図8-2でpipを使いethnicolrをインストールしたいと思います。図8-2のようにダウンロードが始まり、エラーが出なかったら無事インストールが完了したことになります。

"""
pipでインストールする際の書き方
pip install ライブラリ名
"""

図8-2

ライブラリのインストールが完了したら、再度importを試してみましょう。図8-3のようにエラーメッセージが何も表示されなかった場合は無事importが終わり、Notebook内でそのライブラリが使える状態であることを表しています。

図8-3

注釈:pipインストールをする際には、Kaggle Notebookとインターネットの接続が必須になります。電話番号で本人認証をすると接続できるようになります。

Kaggle Notebookの使い方(応用編)

こちらの応用編では、基本編のように絶対に必要な知識とまではいきませんが、知っているとより便利な機能を紹介させていただきます。Notebookの共有およびデータの共有などのコラボレーション機能について紹介します。、Kaggleには個人としてコンペに参加する方法とチームとしてコンペに参加する二つの参加の仕方があります。チームでの参加の際に、この応用編での知識が役立ってくれると思います。

Notebookの共有

こちらでは、一緒に作業したい友人やチームメンバーとのNotebookのシェアの仕方を紹介します。

まずは共有したいNotebookを開いていただいて、図９の「file」から「Share」を選択していただきます。

図９

図10の「Privacy」の部分を「Public」に変更すると、Kaggleを利用している全世界の人に対して公開してしまうので、チームとしてNotebookを共有しあう場合は基本的にチーム内だけでの共有になる「Private」を選択しましょう。

次に、シェアしたい友人などのKaggle内のユーザー名を入力し、選択します。そうすると、「Can view」か「Can edit」を選べるようになります。そして、もし共有相手にNotebookを見てもらうだけで、編集は許可しない場合は「Can view」（閲覧権限）。もし編集まで許可するのであれば「Can edit」（編集権限）を選択して下さい。それで、右下の「Save」をクリックすれば、共有完了です。

図10

データの共有

共同作業をする際に、お互いで学習済みモデルをシェアしたり、前処理済みのテーブルデータをシェアしたりなど、Notebookの共有と共に共同作業中にとても重要なものがデータセットのシェアです。ここではKaggle上でどうやってデータセットのシェアを行うかを紹介します。

Kaggle NotebookのEditorを終了し、Kaggleのトップページにもどってください。図１２にある左のDataをクリックし、その中の「YOUR DATASETS」をクリックします。

図11

その次に共有したいデータを選択し、上の「Settings」のところで、「Add user」に共有したい相手を指定して、先ほどのように権限を指定して、「Save」をクリックすればシェアの完了です。

図12

とても便利な２つのオプション機能

ここまで、Kaggle Notebookについての基本を紹介させていただきました。この項では、ショートカットキーとアクセラレータの使用方法の知っていると、とても便利な二つのオプション機能について紹介させていただきます。

ショートカットキー

このNotebookには数十個のショートカットキーが存在します。このショートカットを覚えれば、いちいちキーボードから手を離してマウスやタッチパッドに手をわざわざ移動させる必要がなくとても便利で時間の節約に役立ちます。

まず、ショートカットを覚える前に、覚えておかなければいけないことが一つあります。それは、Notebookのセルには「コマンドモード」と「編集モード」の二つの状態があることです。

編集モード

図13

セルの中に、タイピングの縦線が見えており、セルの中身が白い状態

この状態ではセルの中に文字を書いたり、文字に対して操作をしたいときに使う状態（セル内をクリックで編集モードに）

コマンドモード

図14

セルの中身が灰色になっている状態。

この状態ではセル自体に何か操作をしたい時に使います。例えばセル自体を削除したり、追加したり。（セルの外をクリックすることでコマンドモードに）

使う頻度の高いショートカットキー一覧

ここで紹介するものは特に使用頻度の高い、セルを操作するキーです。セルを操作する際は常にコマンドモードにしてあることを確認しましょう。使用するOSはwindowsでの説明になりますが、macOSでのcommandがwindowsでのCtrlとほぼ同じ働きをするので、macOSの方も参考にしていただけます。

ショートカットキー	働き
Ctrl + S	保存および上書き保存
B	指定セルの下にセルを挿入
Y	コードセルに変換
M	マークダウンセルに変換
C	セルをコピー
X	選択したセルをカット
V	カットやコピーしたものを貼り付け
DD（D二回入力）	選択したセルの削除

アクセラレータの使用

注釈:アクセラレータを使用する際は、インターネット接続と同様に電話番号での本人認証が必要になりますので、アクセラレータを使用する際Kaggleで電話番号を登録しておきましょう。

アクセラレータとは、GPUやTPUというものを使い、ディープラーニングの計算効率を上げてくれる便利なものです。その違いというのはどれくらいかというと、通常のKaggle Notebookではプログラムの計算にCPUしか使いません。しかし、GPUに同じ計算をさせると4-5倍は違うといわれています。さらに最近Googleが発表したTPUに関しては、ディープラーニング専用に開発されたものであるため、GPUより更に高速になると考えられています。

その機械学習においてとても優秀なアクセラレータの使い方は、先ほどデータを確認するために押していただいた右上の矢印をクリックします。次に、画像のように「Accelerator」の「None」をクリックするとGPUかTPUどちらを使うかを選ぶことができます。

図16

このアクセラレータを使う際に注意点が３つだけあります。一つ目は、GPUおよびTPUはそれぞれ週に３０時間しかつかうことができません。二つ目はアクセラレータを起動すると、使えるメモリが通常１６GBから１３GBに３GBも減ってしまうことです。三つ目はアカウントを二つ以上作ることが禁止されているということです。アクセラレータの上限使用時間になってしまった場合、新しくアカウントを作りそちらでアクセラレータを使用すればいいと思うかもしれませんが、kaggleの公式がその行為は処罰の対象であるとし禁止しています。ですが、このアクセラレータは上手に使えるようになると、とても心強い味方になってくれるはずなので、ぜひ使ってみてください。

まとめ

本稿では、Kaggle Notebookを使い、機械学習モデル開発を始める方法を紹介しました。 紹介しました通り、Kaggle Notebookは機械学習初学者はもちろんのこと、初心者でない方にも使っていただけるNotebookですので、是非各々の使い方を模索して、機械学習モデル開発に 役立ててください。

レコメンド機能ですが、実にありとあらゆる業種で活用されています。

• 商品（EC）
• 映画
• 音楽
• ニュース
• 動画
• …その他多数

今回の機械学習初心者向けチュートリアルでは、k近傍法（K-nearest neighbor）というアルゴリズムを利用して、アニメのレコドメンド機能をPythonを使って一緒に構築してみましょう！

レコメンド機能（エンジン）とは？

まずは、このレコメンド機能とは何かについて一緒に紐解いていきましょう。レコメンド機能とは、データを活用して顧客やユーザーに「お勧め」を提供する情報フィルタリングシステムです。

冒頭でも触れましたが、顧客それぞれの興味や購入履歴に基づいている事から、それぞれの顧客の趣味嗜好に合わせたユーザー体験を提供することが可能な訳です。優秀なレコメンド機能は、ユーザー体験を改善することにより、多くの売上を生み出し、さらには顧客満足度を高めることに大いに役立ちます！

企業は、より優秀なレコメンド機能を構築するために、非常に多くのデータを集めています。集めたデータの量と質により、レコメンド機能の精度が上がることで、より大きな売上と高い顧客満足度へ直結するためです。

ちょっと想像して見てください。もしあなたに機械学習の師匠とも呼べる親しい先輩がいたとして、その先輩が機械学習入門書をお勧めしてくれたら、かなり高い確率でその書籍を購入することを検討しますよね？

なぜなら、あなたは、その先輩の機械学習の知識を信頼している訳ですし、さらには、先輩があなたの機械学習の知識量を知っていることを分かっているため、自分にはその入門書が適切だと考える訳です。

このような「お勧めのプロセス」と似たような体験を、企業は「レコメンド機能」として提供している訳です。ただし、大きな違いとしては、個人的なつながりのある「先輩」の代わりを、膨大かつ多種多様なデータで代用しているのです。

「レコメンド機能」または、その機能の中核となる「レコメンドエンジン」は、多種多様なビジネスに大きな利益をもたらす重要な機能となっており、機械学習の技術が大きく活用されている分野です！

レコメンドエンジンの2つの種類

レコメンド機能の中核となるのが、レコメンドエンジンな訳ですが、大きく分類すると2つの種類があります。ここでは、この2種類のレコメンド機能の概要と、それぞれのメリット/デメリットを簡単に見ていきましょう。

ソース:こちら

英語ではありますが、上記の図を見ながら考えてみましょう。レコメンドエンジンには「協調フィルタリング（Collaborative Filtering）」と「コンテンツに基づくフィルタリング（Content-Based Filtering）」の2種類があります。

協調フィルタリングとは？

協調フィルタリングとは、コミュニティー全体を基にしたレコメンドシステムで、あなたの趣味嗜好や興味が、反映される形のレコメンドエンジンとなります。協調フィルタリングは、あなたの趣味嗜好と類似しているユーザーを探し出して、そのユーザー達の嗜好に基づいて、オススメを行います。

AmazonなどのECサイトの多数では、ユーザーの事細かな情報を持っていますよね。例えば年齢や、住所、商品の購入履歴からレビューなどなど。協調フィルタリングでは、このような各ユーザーの行動（データ）に基づいて、類似したデータを用いることでオススメが可能なわけです。

もっと簡単に言えば、例えばあなたが犬の首輪を購入して、次にトイレットペーパーを購入したとします。この2つの商品を購入したユーザーの情報を分析したところ、「USBメモリ」の購入の確率が高いことが判明したので、あなたにUSBメモリの購入をオススメする流れが「協調フィルタリング」です。（あくまで例です笑）

上記の例を見ても分かる通り、非常に強力なレコメンドエンジンだと思われますが、実は弱点もあります。協調フィルタリングの主な弱点としては、「新しいユーザー」に弱いことです。これは、上の具体例を考えてみると分かりやすいですが、ユーザーへオススメするためのデータが不足しているので、オススメが出来ない（または極端に精度が悪い）わけです。

今回の記事では、この「協調フィルタリング」の仕組みを利用したレコメンド機能を構築します。

コンテンツに基づくフィルタリングとは？

では、もう一方のレコメンド機能も軽く見てみましょう。先の協調フィルタリングでは、「コミュニティ全体の動きに基づいて」オススメを行いましたが、こちらは「あなたの履歴と類似性に基づいて」推薦をしてくれます。

具体的な例で考えてみましょう。例えば、本屋さんのアンケートで「SF」が好きだと答えたとしましょう。そうすると、当然ですが、この書店から届くオススメは「SF」または「SFに類似したカテゴリ」の書籍となる訳ですよね。

このコンテンツに基づくフィルタリングでは、ユーザーが「SF」が好きだと言っているのに、いきなり「料理のレシピ本」のオススメはしない訳です。

このように、このシステムでは以前に好きだった（または購入した）アイテムの特性をみて、それらに似たアイテムを推薦してくれます。例えばECで機械学習の本を購入して高い評価を残したら、そのあとに、そのサイトからオススメされる書籍が機械学習関連になりますよね。

まとめると、「協調フィルタリング＝類似したユーザーに基づいて推薦」で、「コンテンツに基づくフィルタリング＝あなたの履歴に基づいて類似性のある商品を推薦」となります。参考までにですが、この2つのレコメンドエンジンを合体させた「ハイブリッド」を利用しているケースもあります。

企業におけるレコメンド機能の実例

次は、実際に企業で使われているレコメンド機能の実例について紹介させていただきます。冒頭でも触れた通り、レコメンド機能は、売上や顧客満足に密接に関わることから、多くの企業で使われています。

ここで紹介するのはごく一部ですが、特に優れているレコメンドエンジンの実例として見ていきましょう。

【実例1】アマゾン

レコメンド機能の先駆者とも言われるアマゾンですが、サイト内の様々な箇所でレコメンド機能がフル活用されています。下の図ですが、アマゾンで「深層学習」の書籍の詳細ページに表示されているものです。

赤枠で囲っている部分がレコメンド機能で表示されている項目です。図を見れば一目で分かりますが、他のユーザーの購入履歴を基に、この「深層学習」の本と一緒に購入されている書籍をセットでオススメしてくれますし、さらには自身の購入履歴に基づいて、私が購入しそうな商品をオススメしてくれます。

このように、機械学習とユーザー購買履歴データを活用することで、非常にパワフルなツールとなります。一昔前までは、多くのサービスで、単純に「プログラミング」のカテゴリに該当する書籍を推薦していましたが、機械学習を活用することにより、より的確なオススメが可能になる訳です。

【実例2】ネットフリックス

Netflix（ネットフリックス）もレコメンド機能を活用している企業として、頻繁に引き合いに出されます。利用されている方も多いと思いますが、ネットフリックスとは、テレビ番組や映画などをインターネットで視聴できる動画サービスです。

ユーザーがNetflixへログインをすると、トップページで表示される動画は各ユーザーごとに異なります。これは、そのユーザーの視聴履歴、さらに、ユーザー全体のトレンドやあなたとの類似性などに基づいて「オススメの番組/動画」が随時表示される訳です。

米Netflixでは機械学習エンジニアお馴染みの「Kaggle（カグル）」で100万ドル（約1億円）の賞金をかけて、この協調フィルタリング（レコメンド機能）の精度を競うコンペを開催したこともあります。Netflixは、480,189ユーザーの17,770個の映画における、1億個のレビューをデータセットとして公開して、彼らが利用しているレコメンドエンジンの精度を10%向上することを目的としてコンペを実施していました。（参考：Kaggleとは）

Netflixにとって、レコメンド機能が10%向上することは、賞金の約1億円よりも価値が高いと考えている訳です。レコメンド機能がビジネスに対して大きな成果をもたらしている証拠かと思います。

【実例 3】YouTube

レコメンド機能の実例の3つ目はYouTubeの活用事例を紹介します。YouTubeを見ていると、「関連する動画」として、様々な動画を紹介してくれますよね？これも機械学習をフル活用した、最先端のレコメンド機能の良い事例です。

おそらくYouTubeを利用されているほとんどの方が、この「関連動画」の機能を使ったことがあるかと思います。今見ている動画に関連した動画はもちろん、例えば何かしらのシリーズであれば、その続編であったり、テイストが似たような動画だったりと、非常に便利な機能ですよね。

また、ユーザー個別にカスタマイズされているのも非常に実感できます。例えば、友達や知り合いのPCでYouTubeをブラジングすると気づくのですが、普段は自分用にカスタマイズされた「関連動画」ですが、他のPCだといつもと使い勝手が違うと感じるはずです。

ここで紹介したレコメンド機能はごく一部ですが、レコメンド機能と機械学習がビジネスにとってどれほど重要な役割を果たしてるかが、お判り頂けたかと思います。

では、実際にこのレコメンド機能をKaggleのデータセットを利用して構築して見ましょう！

データセットのについて（アニメお勧めデータベース）

まずは、本チュートリアルで利用するデータセットについて説明します。今回ですが、「Anime Recommendations Database（アニメお勧めデータベース）」という、myanimelist.netの76,000ユーザーのアニメのレビューデータを利用します。参考までにですが、このデータ元の「myanimelist.net」は、海外で有名なアニメのサイトで最新から古いタイトルまで非常に幅広いアニメのデータベースを取り揃えています。

このデータセットですが「anime.csv」と「ratings.csv」の2つのCSVファイルにより構成されています。2つのCSVファイルの概要は下記の通りです。

anime.csv 概要

•  anime_id  各アニメのユニークID
•  name  アニメタイトル
•  genre  アニメの属するカテゴリ
•  type  メディアタイプ（例：映画、テレビetc）
•  episodes  アニメのエピソード数
•  rating  最大10の平均レーティング
•  members  当該アニメのグループに参加するユーザー数

ratings.csv 概要

•  user_id  ユニークユーザーID
•  anime_id  当該ユーザーがレートしたアニメID
•  rating  当該ユーザーのレーティング

この2つのCSVファイルを利用してレコメンド機能を構築しましょう。このデータセットですが、おそらくアニメ関連で公開されているデータセットで一番規模が大きいものかと思います。

データの入手方法ですが、下記のKaggleページより会員登録後にダウロードが可能です。下記のリンクから、「rating.csv」と「anime.csv」のダウロードを行いましょう。

アニメデータのダウンロード（Kaggle – 英語）

Pythonでレコメンド機能を構築してみよう

ここからは実際にPythonを使って、k近傍方（k-nearest neighbor）のアルゴリズムを使用して、基本的な「協調フィルタリング」のレコメンドエンジンを構築しましょう！

本チュートリアルですがPython3.6と複数のオープンソースライブラリを使用しています。ライブラリに関しては、よほど古いバージョンでなければ、特に問題ないと思いますが、Pythonは2.xをお使いの方はPython 3.xを使用してください。

必要なライブラリのインポート

まずはお決まりですが、使うライブラリののインポートから行いましょう。ご自身の環境にこれらのライブラリがインストールされていない場合は、インストールが必要です。

環境の構築が面倒い方は、Amazon SageMaker（アマゾン・セージメーカー）もオススメです。SageMakerですが、アマゾンのクラウドで機械学習に必要なライブラリのほぼ全てがインストールされており、簡単に機械学習を始めることが可能です。（詳しくはSageMakerのこちらの記事をご参照ください）

# 使用するライブラリのインポート
import pandas as pd
import numpy as np 
from scipy.sparse import csr_matrix
from sklearn.neighbors import NearestNeighbors

次に、早速、CSVファイルをPandasのデータフレーム形式で読み込んであげましょう。CSVファイルですがKaggleのこちらのページからダウロードが可能です。また、ファイルを保存した先が異なる場合は、下記のコードでファイルパスも指定してあげましょう。

# CSVファイルをデータフレーム形式として読み込み
# 保存先が異なる場合はパスも指定してあげましょう

ratings = pd.read_csv('rating.csv')
anime = pd.read_csv('anime.csv')

本チュートリアルで使用するNumpyなどのライブラリですが、機械学習では頻繁に使用されるツールです。今回、初めて使用される方は、下記の無料入門コースがオススメです！

• Numpy 使い方 入門
• Pandas 使い方 入門
• Matplotlib 使い方入門

データを確認して見ましょう

データの読み込みが完了したので、次はデータの探索をしてみましょう。機械学習では、初めて触るデータはざっくりといじってみて、どのようなデータなのかを把握する作業が一般的です。（詳しくは「探索的データ解析（EDA）」の記事をご覧ください）

まずは、おきまりの head() でデータの最初の5行を表示してみましょう。

# ratingのデータフレームの最初の5行を表示
ratings.head()

# animeデータフレームの最初の五行を表示
anime.head()

次に、このanimeのデータフレームの members の値で並び替えをしてみましょう。この members の値ですが、各アニメの購読メンバー数となていますので、並び替えをすることにより、このデータセット内にあるアニメの中の人気順が把握できるかと思います。

# animeのデータフレームをmemberの値で並び替え
anime.sort_values('members', ascending= False)[:10]

タイトルが英語名なので少し見辛いですが、どうやらこのデータセットで最も購読メンバー数が高いのは「デス・ノート」のようです。2位に「進撃の巨人」、「ソードアート・オンライン」や「鋼の錬金術師」なども上位ですね。

次に describe() の関数を使って、基本統計量を確認してみましょう。

# animeの基本統計量の確認
round(anime.describe(),2)

上の図の基本統計量のテーブルを見てみると、このデータの特性が見えてくるかと思います。例えば、 members の列を見て頂きたいのですが、こちらはmin（最小値）が5.0、max（最大値）が1013917となっています。最小値と最大値のレンジとしては、かなり大きく離れていますね。

また、このデータセット内のアニメの25%が225名以下の購読者数に対して、上位25%は9000名以上の購読者数がいます。人気のアニメとそうでないアニメの差が激しいのも確認できます。

次は同様にratingsのデータフレームの基本統計量も確認してみましょう。

# ratingsの基本統計量の確認
round(ratings.describe(),2)

上記の基本統計量のテーブルをみて、一つ特異なデータがあるのがわかります。 rating のカラムのmin（最小値）が-1とあります。レーティングですが、これはユーザーが各アニメにつけた評価ですよね？最小値の値が「-1」というのはデータとして特異なのが解るかと思います。

データセットの説明文を読んでみると、この「-1」ですが、「アニメを観たことがあるが、レーティング（評価）を付与しなかった」という意味とのことです。このように、データには様々な癖のようなものがあり、それらを最初の段階で把握するのは機械学習において非常に重要な作業です。

次は、このユーザーレーティング（アニメの評価値）のデータ分散を可視化して確認してみましょう。下記コードで、ratingのヒストグラムの生成を行います。（ヒストグラムなどの統計の基本知識が不安な方は、統計入門コースをご参考ください）

# ratingsのヒストグラムを作成
ratings['rating'].hist(bins=11, figsize=(10,10), color = 'red')

レーティングのヒストグラムを確認してみると、「-1」（見たけどレーティングなし）と「7以上」の値がデータのほとんどを占めているのが分かりますね。このように可視化をすることで、データの特性がより素早く確認することが可能です。

データの前処理をしよう

さて、データの一通りの確認ができたら、次はデータの前処理を行います。データの前処理とは、機械学習で利用する前にデータの処理を行うことで、機械が学習をスムーズに行えるようにする為の作業です。

まずはじめに、これから構築するレコメンドエンジンの質を向上する為、 members （当該のアニメのグループに所属しているユーザー数）が10,000以下のデータを足切りをしましょう。足切りすることにより、これから構築するレコメンド機能が、メンバー数が少ないアニメ（つまり比較的人気の低いアニメ）をオススメしないようになります。

＊参考までにですが、今回は10,000という値を閾値（いきち）として選びましたが、この値は適当に決めた値であり、本来であれば、より詳細を確認しながら設定するものです。

# membersの値が10,000より大きいデータのみに変更
anime = anime[anime['members'] > 10000]

次は、こちらも機械学習で定番の作業ですが、欠損値の処理を行いましょう。実際のプロジェクトなどで使うデータセットですが、殆どの場合でデータが「欠損（つまり欠けている）」います。完璧に全てのデータが揃っている方が珍しいくらいです。実際に機械学習のアルゴリズムを使ってモデルを構築する前に、この欠損したデータは何かしらの処理をしなくてはいけません。

# 欠損データの確認
anime.isnull().sum()

今回のアニメのデータセットでも、非常に少ない割合ではありますが欠損が確認できます。欠損データの扱いですが、こちらも様々な処理方法がありますが、今回は一番単純な方法・・・削除をしましょう。

# 欠損データをdropna()でデータセットから取り除く
anime = anime.dropna()

必要最低限ではありますが、これでanimeのデータのクリーニングが出来ましたので、次はratingのデータにも簡単な前処理を加えてあげましょう。

先のデータ確認の項目でやりましたが、ratingsのデータには「-1（見たけど評価しなかった）」が含まれています。まずは、この「-1」のデータを取り除きましょう。

# raitingの値が0以上のみ残す
ratings = ratings[ratings.rating >= 0]

念のため、改めてratingsの基本統計量を確認しておきましょう。

ご覧の通り先ほどはレーティングの最小値（min）が-1とありましたが、データの前処理を行いましたので「1」へと変わっているのが確認できます。不要なデータを取り除きましたが、まだ6,337,241件のレーティングと非常に膨大なデータが残っていますね！

次にanimeとratingsのデータを「 anime_id 」を軸にして、「user_id」毎に切り分けてマージさせましょう。

# animeとratingsの2つのデータフレームをマージさせる
mergeddf = ratings.merge(anime, left_on = 'anime_id', right_on = 'anime_id', suffixes= ['_user', ''])

# 合体したデータフレームの最初の5行を表示
mergeddf.head()

これで、2つの異なるデータフレームが、ユーザーIDごとに切り分けられた一つのデータフレームとしてマージ（合体）しました。（参照：pandasの merge() は非常に重要な処理です。詳しくはPandas入門コースをご参照ください）

参考までに、このマージさせたデータフレームの基本統計量も確認しておきましょう。

# mergeddfの基本統計量の確認
round(mergeddf.describe(),2)

さて、ここまでいじってきたデータセットですが、今回のレコメンド機能に使うデータは「 user_id 」「 name 」「 rating_user 」の3項目のみです。データの前処理の最後の項目として、使わないデータ項目の削除と重複データのカットを行いましょう。

# 不必要な項目と重複項目を削除
mergeddf = mergeddf[['user_id','name','rating_user']]
mergeddf = mergeddf.drop_duplicates(['user_id','name'])

# head()で最初の5行を表示
mergeddf.head()

さて、次の処理ですが、 name （アニメのタイトル名）がデータフレームのインデックスに、 user_id をカラムとして、ピボットさせましょう。文字で見ると、いまいち分かりにくいかも知れませんが、実際にデータフレームを処理して見てみると分かるかと思います。

またピボットの処理と併せて、ユーザーが評価していないアニメに関しては  fillna(0) で「0」の値を入れてあげましょう。

# データフレームのピボット
anime_pivot = mergeddf.pivot(index= 'name',columns='user_id',values='rating_user').fillna(0)
anime_pivot_sparse = csr_matrix(anime_pivot.values)

こちらのピボットの処理ですが、アニメのタイトル名（name）をデータフレームのインデックスとして、各カラムがユーザーを表しています。当該のユーザーがレーティングをして入れば、数字が入っており、レーティングがないアニメに関しては「0」と値が入っています。簡単なイラストで表すと下記のような図です。

参考までにですが、このようにほとんどのデータの値が「0」となるような行列を「疎行列（そぎょうれつ – Sparse martrix）」と呼びます。

では、実際にピボット処理を行ったこの疎行列の最初の10行を表示させて見ましょう。

# anime_pivotの最初の10行を表示
anime_pivot.head(10)

先ほど説明した通り、データフレームのindex（上記表でいう一番左の部分）がアニメのタイトルになっており、各列がユーザーのIDを表しているのが分かります。

k近傍法（k-nearest neighbors）でレコメンド機能を構築

さて、いよいよ本題のレコメンド機能の構築です！今回構築するレコメンド機能ですが、k近傍法（ケイ・きんぼうほう）というアルゴリズムを利用してモデルを構築します。k近傍法ですが英語の「k-nearest neighbor（ケイ・ニアレスト・ネイバー）」またはその頭文字を取って「KNN」と呼ばれることも多いので、覚えておくと便利かと思います。

では、このk近傍法とは一体どのようなアルゴリズムなんでしょうか？

k近傍法ですが最も単純なアルゴリズムと呼ばれており、クラスタリングのアルゴリズムの一種で、一般的に分類問題などで利用されます。今回のチュートリアルの例で考えると、とあるアニメのタイトルを入力した際に、そのアニメのneighbors（ご近所さん）を探して、距離が近い（類似性が高い）アニメのタイトルをオススメとして返してくれます。

かなりざっくりとした説明ですが、より詳しくk近傍法について調べて見たい方は、こちらのページをご参照ください。

では、実際にこのk近傍法のアルゴリズムと事前に処理したデータセットを使ってモデルを構築してみましょう！今回ですが、初心者向けのチュートリアルですので、Pythonの機械学習ライブラリ「Scikit-learn（またはSklearnとも呼ばれる）」を利用しましょう。

# Scikit-learnのライブラリを利用します
# n_neiborsやalgorithm、metricなど重要なアーギュメントを設定しています
knn = NearestNeighbors(n_neighbors=9,algorithm= 'brute', metric= 'cosine')

# 前処理したデータセットでモデルを訓練
model_knn = knn.fit(anime_pivot_sparse)

これで、モデルの構築と前処理したデータセットでの訓練が完了です！ライブラリを使うと、想像以上に簡単ですよね？では、いよいよ、この構築したアニメのレコメンド機能の実力を試してみましょう！

構築したレコメンド機能を試してみる

まず最初に、今回のデータセットですが全てアニメタイトルが英名で記載されており、探すのに一苦労しますので、簡単な検索機能を作ってあげましょう。試しに「hajime」で検索してみます。

# データセットのタイトルをキーワードで検索
def searchanime(string):
    print(anime_pivot[anime_pivot.index.str.contains(string)].index[0:])
    
searchanime('Hajime')

タイトルに「hajime」を含むアニメの一覧が戻ってきましたね。 searchanime(”) にキーワードを入力すると、そのワードを含むアニメタイトルが戻ってきます。ご自身で色々なアニメで確認される際は、是非こちらの機能を使ってみてください。（文字ですが大文字小文字のケースセンシティブなのでご注意を）

では、いよいよ構築したレコメンド機能の実力を試してみましょう！アニメタイトルを入力すると、モデルは10個のオススメのアニメタイトルを返してくれるはずです。

まずは…私が個人的に好きな「はじめの一歩（Hajime no Ippo）」からみてみましょう！

# 「はじめの一歩」に対してのオススメのアニメ10個
Anime = 'Hajime no Ippo'

distance, indice = model_knn.kneighbors(anime_pivot.iloc[anime_pivot.index== Anime].values.reshape(1,-1),n_neighbors=11)
for i in range(0, len(distance.flatten())):
    if  i == 0:
        print('Recommendations if you like the anime {0}:\n'.format(anime_pivot[anime_pivot.index== Anime].index[0]))
    else:
        print('{0}: {1} with distance: {2}'.format(i,anime_pivot.index[indice.flatten()[i]],distance.flatten()[i]))

う〜ん…ある意味正しいといえば正しいのですが、「はじめの一歩」と入力したら上位5位は全て「はじめの一歩」のシリーズがオススメとして返ってきています。結果としては少し面白みにかけましたが、「はじめの一歩」が好きな人にオススメするタイトルとしては、ある意味一番正しい答えのようにも感じます。

ちなみに、 distance とありますが、こちらの数値が低ければ低いほど、類似性が高い、つまりオススメ度が高いことを表しています。

では次は…個人的に大絶賛のアニメ「君の名は」で調べてみましょう！

# 「君の名は」を見たことがあるあなたにオススメのアニメは・・・
Anime = 'Kimi no Na wa.'

distance, indice = model_knn.kneighbors(anime_pivot.iloc[anime_pivot.index== Anime].values.reshape(1,-1),n_neighbors=11)
for i in range(0, len(distance.flatten())):
    if  i == 0:
        print('Recommendations if you like the anime {0}:\n'.format(anime_pivot[anime_pivot.index== Anime].index[0]))
    else:
        print('{0}: {1} with distance: {2}'.format(i,anime_pivot.index[indice.flatten()[i]],distance.flatten()[i]))

おおお！レコメド機能が推薦してくれたのは・・

1位「僕だけがいない街」
2位「Re:ゼロから始める異世界生活」
3位「四月は君の嘘」
4位「ReLife」
5位「ワンパンマン」

「ワンパンマン」がランクインしていることで、色々と考えさせられる結果ではありますが（笑）、他のタイトルを見ても、個人的には「四月は君の嘘」以外は全て見たことがあり、かつ私の中では高評価なアニメです！「四月は君の嘘」に関しても、少し調べて見ましたが・・これは観てみたい！と思わされました。

と、いうことで・・今回のアニメレコメンドシステムですが、（個人的には） 合格点 かと思います！

まとめ

今回は機械学習ライブラリを使って、非常に単純なレコメンドシステムを構築してみました。いかがでしたでしょうか？決して、精度の高いレコメンド機能とは言えませんでしたが、これを土台として機械学習を活用したレコメンド機能の構築の最初の一歩になれば幸いです。

別種類の「コンテンツに基づくフィルタリング」のレコメンド機能に関しても、また後日、チュートリアルを予定しています。ご興味がある方は、 Twitterのフォローを頂けると幸いです。

また、他にも「ゲームの売上予測」や「タイタニック号の生存予測」など、初心者でも気軽に行える機械学習チュートリアルを公開していますので、是非、別のチュートリアルにも挑戦してみてください。

• タイタニック号で生き残るのは誰？
• ゲームソフトの売行きをXGBoostで予測してみた
• ビットコインとイーサリアムの翌日の価格を予測する方法

以上、「機械学習を使って630万件のレビューに基づいたアニメのレコメンド機能を作ってみよう」となります。チュートリアルに最後までお付き合い頂きまして、ありがとうございます！

さて、先日に公開した、第一弾チュートリアル「Amazon SageMakerを使って銀行定期預金の見込み顧客を予測【SageMaker ＋XGBoost 機械学習初心者チュートリアル】」に続いて、今回は第二弾のAmazon SageMaker初心者向けチュートリアルとなります！

前回は銀行の定期預金マーケティングの予測でしたが、今回はゲームソフトの売行き予測をXGBoostで行います。本チュートリアルの概要は下記となります。（チュートリアル参照元はこちら）

チュートリアルに掛かる時間

1時間〜3時間程度で実施可能です

発生するAWS料金

最低限のインスタンスを利用して3ドル〜5ドルとなります。SageMakerの無料枠の利用も可能ですので、使える方は無料枠でお試しください。 無料枠を利用しない限りは、料金が発生します。インスタンスの選択など、必ず各自の責任で本チュートリアルを実施ください。 

本チュートリアルで実施する概要

• Amazon SageMakerのノートブックでデータ前処理
• Boto3経由でS3とSagaMakerの連携
• モデルトレーニングインスタンスでSageMaker XGBoostの訓練
• モデルホスティングインスタンスで訓練済みモデルをホスト
• テストデータをホスティングしたモデルを使って予測値を取得
• 結果確認

今回ですが第二回目となりますので、登録や初期設定の詳細に関しては省いています。まだSageMakerを一度も触られたことがない方は、第一弾目からどうぞ。

では、早速、やってみましょう！

SageMaker ノートブックインスタンスの立ち上げ

SageMakerのメリットの一つとして、クラウドでJupyter Notebookが簡単に使えることです。機械学習で必要なライブラリやフレームワークが、すでに使える環境ですので、大きな時間短縮となります。

では、SageMakerへログインをしてノートブックインスタンスの立ち上げを行なっていきましょう。まだSageMakerのアカウントをお持ちでない方は、こちらから登録をお願いいたします。

インスタンスの立ち上げですが、基本的には下記の3つの設定が必要なります。

• ノートブックインスタンス名
• ノートブックインスタンスのタイプ
• IAMロール

今回はノートブックインスタンス名を「hit-games」と名付けて作成しました。インスタンスのタイプは、一番安い「ml.t2.medium」を利用しています。無料枠が利用可能な方は、こちらへ無料枠用のタイプが出ているかと思いますので、適宜、そちらを選んで下さい。SageMakerの料金設定はこちらのページを各自参照して、料金を理解した上での利用をお願い致します。また、IAMロールの設定はSageMaker一段目チュートリアルをご参照ください。

ノートブックインスタンスの立ち上げが完了したら、次はJupyter Notebookで新しいノートを作成しましょう。下記の画面の「New」のドロップダウンから「conda_python3」を選択して、新規ノートブックを作成します。

これで、ノートブックインスタンスの準備完了です。次にS3のバケット名とリージョンの確認を行いましょう。S3とSageMakerのリージョンが異なると、使えませんので気をつけましょう。S3のコンソールへログインをして、バケット名とリージョンの確認をお願いいたします。本チュートリアルでは、SageMakerの「米国東部（バージニア北部）」を利用していますので、s3も同様のリージョンで作られているのが確認できます。

これで、ノートブックインスタンスの作成は完了です。S３のバケット名ですが、後ほど使いますので、どこかにメモっておきましょう。

次はデータセットの取得とノートブックインスタンスを利用して前処理へ進みましょう！

データセットの取得

本チュートリアルで使うデータセットはKaggleのVideo Game Sales with Ratings（意訳：ビデオゲームの売上とレビュー）を使います。Kaggleにまだ登録されていない方は、この機会に登録をお勧めいたします。（Kaggleの詳しい説明はこちらをご参考）

登録完了後に「Data」のページからデータセットのダウロードが可能です。 Video_Games_Sales_as_at_22_Dec_2016.csv をローカルにダウロードしましょう。

データセットのダウロードが完了したら、次はS3へアップロードを行います。SageMakerと同じリージョンのS3のバケット直下へ、 Video_Games_Sales_as_at_22_Dec_2016.csv のアップロードをしてください。

次に、SageMaker ノートブックで、S3へ格納したデータセットを読み込んで、データの前処理を行います。先ほど作成したノートブックを開きましょう。

まずは、S3のバケット名の指定、さらにS3で使うプレフィックスとIAM Roleの宣言をしましょう。ノートブックの一番最初のセルへ下記のコードを入力して、Shift + Enterで実行しましょう。

bucket = 'hideto-ml'
prefix = 'sagemaker/videogames_xgboost'

# IAMのRoleを宣言
import sagemaker
role = sagemaker.get_execution_role()

次に本チュートリアルで使う機械学習系のライブラリのインポートを一括で行います。今回使うライブラリですが、全てSageMakerにインストール済ですので、特に事前の作業は必要ありません。

NumpyやPandasなどの機械学習定番のライブラリに加えて、PythonとAWSをブリッジングしてくれるboto3も使います。

# 必要なライブラリのインポートをしましょう
# すべてsagemakerで用意されていますので追加作業なし
import numpy as np                                
import pandas as pd                               
import matplotlib.pyplot as plt   
from IPython.display import Image                 
from IPython.display import display               
from sklearn.datasets import dump_svmlight_file   
from time import gmtime, strftime                 
import sys                                        
import math                                       
import json
import boto3

次は先ほどKaggleからダウロードして、S3へ格納したファイルの読み込みを行います。ファイル名を指定して、Boto3経由でS3からSageMakerへファイルを移しましょう。さらに、CSVファイルからPandasデータフレームへの変換も行なって、データの表示をしてみましょう。

# KaggleからダウロードしたデータセットをS3のバケットへ格納
# ファイル名を指定する
raw_data_filename = 'Video_Games_Sales_as_at_22_Dec_2016.csv'


# boto3経由でs3内に格納したデータをSageMakerのノートブックインスタンスへ移します
s3 = boto3.resource('s3')
s3.Bucket(bucket).download_file(raw_data_filename, 'raw_data.csv')


# PandasのデータフレームへCSVファイルを変換
# Pandasの行表示制限のオプション設定を変更
# データを表示させる
data = pd.read_csv('./raw_data.csv')
pd.set_option('display.max_rows', 20)
data

次は、このデータセットの概要の確認と予測ターゲットの設定を行います。

データセットの確認と予想ターゲットの設定

こちらのデータセットですが、KaggleのDataのページにて詳細が記載してあります。各項目の概要を紐解いていきましょう。データの提供元はMetacritic（メタクリティック）という、ゲームや音楽などをレビュー集積するウェブサービスとなっています。

各項目の概要

•  Name  ゲームタイトル
•  Platform  ゲーム機種別
•  Year_of_Release  ゲーム発売年
•  Genre 
• ゲームのカテゴリ
•  Publisher 
• ゲーム販売者名
•  NA_Sales  北米の販売数（単位：百万）
•  EU_Sales  ECの販売数（単位：百万）
•  JP_Sales  日本の販売数（単位：百万）
•  Other_Sales  上記以外の地域の販売数（単位：百万）
•  Global_Sales  全世界の合計販売数（単位：百万）
•  Critic_Score  メタクリティックが統計したスコア
•  Critic_Count  Critic_Scoreの算出元となるレビュー数
•  User_Score  メタクリティックのユーザーがつけた評価スコア
•  User_Count  User_Scoreの算出元となるユーザー数
•  Developer  ゲーム開発名
•  Rating  アメリカのゲーム利用の年齢制限レーティング

データセット概要

• 16719行16列のデータセット
• Name（ゲームタイトル）のユニーク数は約1200
• Platform（ゲーム機）のユニー数は31
• Global_SalesなどSales関連の単位は全てMillion（百万）
• Global_Salesの平均値は0.53（つまり53万個の販売数）

余談ではありますが、こちらのデータを色々と深掘りしてみると面白いですね！別途、時間がある方は深掘りして見ると、データセットの処理の良い勉強になるかと思います！

さて、次は予測ターゲットの設定を考えましょう。今回の予測ターゲットですが、「ゲームソフトがヒットするかどうか」を予測しましょう。ヒットの定義として、ゲームソフトが100万本以上売れたらヒット（ミリオンセラー）とします。

ということで、 Global_Sales のデータ値を参照して、予測ターゲット y を作成しましょう。さらに、今回のデータセットでのミリオンセラーの分布を確認してみましょう。

# ターゲットを設定
# Global_Salesで1（100万本）以上の売上を基準としてyを作成
data['y'] = (data['Global_Sales'] > 1)

# ターゲットの分布を確認
plt.bar(['not a hit', 'hit'], data['y'].value_counts())
plt.show()

当然といえば当然ですが、ミリオンセラーの販売実績は非常に高い壁のようですね（笑）。莫大なお金と時間を投じても、売れるゲームと売れないゲームがあるという厳しい現実を表したデータです。

予測ターゲットの設定ができましたので、次はいよいよ特徴量を決めていきましょう。データの各項目を見てみると、予測ターゲット（ Global_Sales ）に特に関係が強うそうなデータとして、 User_Score と Critic_Score が考えられます。この2項目のデータと予測ターゲットyの相関を対数目盛を利用してプロッティングしてみましょう。

# 次は特徴量を決めます
# ゲームのレビュー（User_ScoreとCritic_Score）と販売量（Global_Sales）の相関性は？
# 対数目盛を使ってグラフにしてみよう
viz = data.filter(['User_Score','Critic_Score', 'Global_Sales'], axis=1)
viz['User_Score'] = pd.Series(viz['User_Score'].apply(pd.to_numeric, errors='coerce'))
viz['User_Score'] = viz['User_Score'].mask(np.isnan(viz["User_Score"]), viz['Critic_Score'] / 10.0)
viz.plot(kind='scatter', logx=True, logy=True, x='Critic_Score', y='Global_Sales')
viz.plot(kind='scatter', logx=True, logy=True, x='User_Score', y='Global_Sales')
plt.show()

左が Critic_Score で右が User_Score のグラフとなります。想像の通り両方のデータはターゲット y の予測をするのに使えそうなのが解ります。他にも genre （ゲームのカテゴリ）も当然、ミリオンセラーの要因になりますし、 ESRB （米ゲーム年齢制限レーティング）も販売対象となるリーチが大きく異なることから（例：全ての年齢対象のソフトより成人対象のソフトはリースが少ない）、予測ターゲットの特徴量として使えるかと思います。ここでは、他の項目とターゲット y との相関を出しませんが、各自でデータを確認してみてください。

次ですが、特徴量として使えない（使わない）項目を考えましょう。すでにデータをパッと確認したら気づくかと思いますが、 JP_Sales （日本での販売数）など、予測ターゲットに直接関係のあるデータが含まれています。これらの項目は予測モデルに組み込むべきではありませんので、除外しましょう。、あた、 Name （ゲームタイトル）や Year_of_Release （販売開始年）なども除外します。

# 特徴量として使わない項目を除外
data = data.drop(['Name', 'Year_of_Release', 'NA_Sales', 'EU_Sales', 'JP_Sales',
                  'Other_Sales', 'Global_Sales', 'Critic_Count', 'User_Count', 'Developer'], axis=1)

これで訓練に使う項目のみが残りましたので、次はお決まりの欠損値の確認を行いましょう。 missing_values_table の関数を作成して、 data の各項目（特徴量）の欠損値の状況把握をします。

# 欠損データの確認 missing_values_tableを作る
def missing_values_table(df):
    mis_val = df.isnull().sum()
    mis_val_percent = 100 * df.isnull().sum()/len(df)
    mis_val_table = pd.concat([mis_val, mis_val_percent], axis=1)
    mis_val_table_ren_columns = mis_val_table.rename(
    columns= {0 : 'Missing Values', 1: '% of total values'})
    return mis_val_table_ren_columns

# まずはおきまりの欠損データの状況を確認しておこう
missing_values_table(data)

見たところ、 Critic_Score 、 User_Score 、 Rating は50％近くの割合で欠損していますね…。機械学習の醍醐味として、この欠損データをどのように処理を行うかで実力の差が出るのですが、今回はもっともシンプルな方法で処理をしましょう。そう、その方法とは・・除外することです。（失礼しました笑）

# 欠損データを除外しよう
data = data.dropna()

これで、欠損データは全て除外されて綺麗になりました。欠損データと同様に、データ値が使えない場合も多々あります。dataを隅々まで確認すると、どうやら User_Score に tbd というストリングの値が含まれています。 User_Score を数値として処理をしたいのに、これは不都合です。

この User_Score の tbd をNaNに変換しましょう。すでに約40%もの User_Score を除外してしまっていますので、これ以上データを絞るのはあまりしたくありません。ですので tbd の値を一度NaNに変換して、さらに相関関係が非常に高い Critic_Score を元にNaNへ代入しましょう。

上の図でもわかり通り、 User_Score は Critic_Score の約1/10となっています。完璧な代入には当然なりませんが、それでもこれ以上データを除外するよりかはマシかと思いますので、その流れで tbd を処理しましょう。

# User_Scoreの数値以外の値を処理
data['User_Score'] = data['User_Score'].apply(pd.to_numeric, errors='coerce')

# Critic_Scoreの1/10をUser_SocoreのNaNへ代入
data['User_Score'] = data['User_Score'].mask(np.isnan(data["User_Score"]), data['Critic_Score'] / 10.0)

データの前処理もほとんど終わりです。次は、予測ターゲットの y を扱いやすいように処理して、データ前処理で定番のダミー変数化をしましょう。

# 予測ターゲットを扱いやすいように処理
data['y'] = data['y'].apply(lambda y: 'yes' if y == True else 'no')

# 全ての特徴量をダミー変数化
model_data = pd.get_dummies(data)

これで、特徴量の前処理は完了です！次は過学習対策として、データを3つのグループへ分けましょう。今回のチュートリアルでは全体の70%を学習用データとして分けて、20%を評価用データとして使いましょう。残りの10%は最終のテスト用データとして残しておきます。

# train_dataを3つのデータセットへ分別
train_data, validation_data, test_data = np.split(model_data.sample(frac=1, random_state=1729), [int(0.7 * len(model_data)), int(0.9 * len(model_data))])

さて、いよいよデータ前処理の最後のステップとなります。最後は、XGBoost用にlibSVM形式へ変換をして、boto3を経由してS3へファイルを送りましょう。

# libSVM形式へ変換
dump_svmlight_file(X=train_data.drop(['y_no', 'y_yes'], axis=1), y=train_data['y_yes'], f='train.libsvm')
dump_svmlight_file(X=validation_data.drop(['y_no', 'y_yes'], axis=1), y=validation_data['y_yes'], f='validation.libsvm')
dump_svmlight_file(X=test_data.drop(['y_no', 'y_yes'], axis=1), y=test_data['y_yes'], f='test.libsvm')

# boto3経由でlibSVMをS3へ送る
boto3.Session().resource('s3').Bucket(bucket).Object(prefix + '/train/train.libsvm').upload_file('train.libsvm')
boto3.Session().resource('s3').Bucket(bucket).Object(prefix + '/validation/validation.libsvm').upload_file('validation.libsvm')

上記のコードを実行した後に、念のためS3を確認しておきましょう。下記のキャプチャのように、libSVMファイルがS3へ格納されているはずです。

以上でデータの前処理が完了しました！次から、SageMakerのモデルトレーニングインスタンスを立ち上げてモデル構築、さらにはモデルホスティングインスタンスでモデルを使えるようにしましょう。

モデルトレーニング

データの処理が完了したところで、次はXGBoostのモデルの訓練を始めましょう。XGBoostですが、多数のハイパーパラメーターが用意されていますが、今回はその中のいくつか初歩的なものを使ってトレーニングを行いましょう。

さて、次はノートブックでモデルトレーニングを実行していきましょう。手順として、まずは訓練のジョブ用に必要なパラメータ設定して、その後に訓練のジョブを動かします。

コードを動かす前に重要な点が一つ！SageMakerですが、ノートブック、モデルトレーニング、モデルホスティングの各インスタンスで料金が異なります。全てのインスタンスで本チュートリアルでは、全てい最小限のものを利用しています。インスタンスの料金は、各自、必ず理解をした上で実行をお願い致します。

では、モデルトレーニングをやっていきましょう！まずは、パラメーターの設定をしましょう。

job_name = 'videogames-xgboost-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print("Training job", job_name)

containers = {
                'us-west-2': '433757028032.dkr.ecr.us-west-2.amazonaws.com/xgboost:latest',
                'us-east-1': '811284229777.dkr.ecr.us-east-1.amazonaws.com/xgboost:latest',
                'us-east-2': '825641698319.dkr.ecr.us-east-2.amazonaws.com/xgboost:latest',
                'eu-west-1': '685385470294.dkr.ecr.eu-west-1.amazonaws.com/xgboost:latest'
             }

create_training_params = \
{
    "RoleArn": role,
    "TrainingJobName": job_name,
    "AlgorithmSpecification": {
        "TrainingImage": containers[boto3.Session().region_name],
        "TrainingInputMode": "File"
    },
    "ResourceConfig": {
        "InstanceCount": 1,
        "InstanceType": "ml.c4.xlarge", # こちらでインスタンスタイプが調整可能です！
        "VolumeSizeInGB": 10
    },
    "InputDataConfig": [
        {
            "ChannelName": "train",
            "DataSource": {
                "S3DataSource": {
                    "S3DataType": "S3Prefix",
                    "S3Uri": "s3://{}/{}/train".format(bucket, prefix),
                    "S3DataDistributionType": "FullyReplicated"
                }
            },
            "ContentType": "libsvm",
            "CompressionType": "None"
        },
        {
            "ChannelName": "validation",
            "DataSource": {
                "S3DataSource": {
                    "S3DataType": "S3Prefix",
                    "S3Uri": "s3://{}/{}/validation".format(bucket, prefix),
                    "S3DataDistributionType": "FullyReplicated"
                }
            },
            "ContentType": "libsvm",
            "CompressionType": "None"
        }
    ],
    "OutputDataConfig": {
        "S3OutputPath": "s3://{}/{}/xgboost-video-games/output".format(bucket, prefix)
    },
    "HyperParameters": {
        "max_depth":"3",
        "eta":"0.1",
        "eval_metric":"auc",
        "scale_pos_weight":"2.0",
        "subsample":"0.5",
        "objective":"binary:logistic",
        "num_round":"100"
    },
    "StoppingCondition": {
        "MaxRuntimeInSeconds": 60 * 60
    }
}

次に、モデル訓練のジョブの実行です。こちらですが、本チュートリアルで使用したインスタンス（ ml.c4.xlarge ）で約6分程処理に掛かりました。

%%time

sm = boto3.client('sagemaker')
sm.create_training_job(**create_training_params)

status = sm.describe_training_job(TrainingJobName=job_name)['TrainingJobStatus']
print(status)

try:
    sm.get_waiter('training_job_completed_or_stopped').wait(TrainingJobName=job_name)
finally:
    status = sm.describe_training_job(TrainingJobName=job_name)['TrainingJobStatus']
    print("Training job ended with status: " + status)
    if status == 'Failed':
        message = sm.describe_training_job(TrainingJobName=job_name)['FailureReason']
        print('Training failed with the following error: {}'.format(message))
        raise Exception('Training job failed')

これで、事前に処理したデータセットとSageMakerのXGBoostの訓練が、モデルトレーニングインスタンス上で完了できました。この訓練したモデルのホスティングをSageMakerを使ってやってみましょう。

モデルホスティングの実施

SageMakerのサーバーレスエンドポイントでのホスティングをやってみましょう。

# スコアリングコンテナとmodel.tar.gzを指定してホスティングモデルを作成する
create_model_response = sm.create_model(
    ModelName=job_name,
    ExecutionRoleArn=role,
    PrimaryContainer={
        'Image': containers[boto3.Session().region_name],
        'ModelDataUrl': sm.describe_training_job(TrainingJobName=job_name)['ModelArtifacts']['S3ModelArtifacts']})

print(create_model_response['ModelArn'])

次にホスティングエンドポイントの設定をいくつかしましょう。具体的には、ホスティングで使うEC2インスタンスの指定や、初期で使うインスタンスの個数、さらにはホストされているモデルの名前の設定をします。

xgboost_endpoint_config = 'videogames-xgboost-endpoint-config-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print(xgboost_endpoint_config)
create_endpoint_config_response = sm.create_endpoint_config(
    EndpointConfigName=xgboost_endpoint_config,
    ProductionVariants=[{
        'InstanceType': 'ml.t2.medium',
        'InitialInstanceCount': 1,
        'ModelName': job_name,
        'VariantName': 'AllTraffic'}])

print("Endpoint Config Arn: " + create_endpoint_config_response['EndpointConfigArn'])

さて、最後にモデルのホスティングの実行しましょう。こちらですが、完了するまでに16分程度掛かりました。

%%time

xgboost_endpoint = 'EXAMPLE-videogames-xgb-endpoint-' + strftime("%Y%m%d%H%M", gmtime())
print(xgboost_endpoint)
create_endpoint_response = sm.create_endpoint(
    EndpointName=xgboost_endpoint,
    EndpointConfigName=xgboost_endpoint_config)
print(create_endpoint_response['EndpointArn'])

resp = sm.describe_endpoint(EndpointName=xgboost_endpoint)
status = resp['EndpointStatus']
print("Status: " + status)

try:
    sm.get_waiter('endpoint_in_service').wait(EndpointName=xgboost_endpoint)
finally:
    resp = sm.describe_endpoint(EndpointName=xgboost_endpoint)
    status = resp['EndpointStatus']
    print("Arn: " + resp['EndpointArn'])
    print("Status: " + status)

    if status != 'InService':
        message = sm.describe_endpoint(EndpointName=xgboost_endpoint)['FailureReason']
        print('Endpoint creation failed with the following error: {}'.format(message))
        raise Exception('Endpoint creation did not succeed')

実行したセルの下に、上記のようなメッセージが出れば成功です！

構築したモデルでテストデータを使って予測

やっと、①データの前処理②モデルトレーニング③モデルホスティングが完了しました！次はいよいよ、この構築したモデルを使って、予め切り分けておいたテスト用データを使って予測してみましょう。

runtime = boto3.client('runtime.sagemaker')

def do_predict(data, endpoint_name, content_type):
    payload = '\n'.join(data)
    response = runtime.invoke_endpoint(EndpointName=endpoint_name, 
                                   ContentType=content_type, 
                                   Body=payload)
    result = response['Body'].read()
    result = result.decode("utf-8")
    result = result.split(',')
    preds = [float((num)) for num in result]
    preds = [round(num) for num in preds]
    return preds

def batch_predict(data, batch_size, endpoint_name, content_type):
    items = len(data)
    arrs = []
    
    for offset in range(0, items, batch_size):
        if offset+batch_size < items:
            results = do_predict(data[offset:(offset+batch_size)], endpoint_name, content_type)
            arrs.extend(results)
        else:
            arrs.extend(do_predict(data[offset:items], endpoint_name, content_type))
        sys.stdout.write('.')
    return(arrs)

%%time
import json

with open('test.libsvm', 'r') as f:
    payload = f.read().strip()

labels = [int(line.split(' ')[0]) for line in payload.split('\n')]
test_data = [line for line in payload.split('\n')]
preds = batch_predict(test_data, 100, xgboost_endpoint, 'text/x-libsvm')

print ('\nerror rate=%f' % ( sum(1 for i in range(len(preds)) if preds[i]!=labels[i]) /float(len(preds))))

これで・・切り分けておいた10%のテストデータを使って、構築したモデルで予測が完了しました。機械学習をやっていると、いつもこの瞬間がドキドキします。癖になりますよね（笑）

予測結果の評価ですが、様々な評価方法が存在します。今回は非常にシンプルに、実際の正解データと予測データを付け合わせたテーブルをPandasで作成して、そちらを確認してみましょう。

pd.crosstab(index=np.array(labels), columns=np.array(preds))

こちらが今回の結果となります。テストデータ803件を訓練済みXGBoostモデルで予測をしたところ、ミリオンセラーと予測した122件のゲームソフトのうち、73件が実際にミリオンセラーでした！

加えて、今回のモデルでは、803件のゲーム中、681件はミリオンセラーにならないと予測して、実際は622件が100万本届かなかったゲームと言えます。（うち59件はミリオンセラーとなりました）

まとめ

Amazon SageMakerでXGBoostを使った機械学習チュートリアルですが、いかがでしたでしょうか？SageMakerは全てのエンジニアが気軽に機械学習ができることを目的として作られたサービスです。

いくつか癖のある、覚えなくてはいけない箇所（特にモデルホスティング）はあるものの、一概として非常に簡単に、しかも素早く機械学習を実装できるという点では優れたサービスです！

また、機械学習を初めてばかりで、もっと触ってみたいとお考えの方は、下記の初心者向けチュートリアルも是非やってみてください。（下記はAmazon SageMakerではなく、Jupyter Notebookと各ライブラリを使って実施してます）

• Kaggle リクルート ホットペッパーチャレンジ
• Kaggle リクルート ホットペッパーチャレンジ
• Kaggle タイタニック チャレンジ

以上、SageMakerの初心者向けチュートリアル第二弾でした！近日中に今回使用したXGBoostの詳細チュートリアルも予定していますので、興味のある方はコデクサのfacebookまたはTwitterのフォローをお願い致します！

リクルートのKaggleコンペ第一回目は同社が運営するクーポンサイト「ポンパレ」の顧客情報からの購入するクーポンの予測（レコメンデーション）を行うものでした。

今回の第二回目のKaggleリクルートコンペでは、同じく同社が運営する「ホットペッパー」と「Airレジ（飲食店向けPOSレジアプリ）」のデータを利用して、レストランのお客さんの数を予測するコンペとなっています。

すでに簡単な予測モデルでのカーネル（Kaggleの公開コーディング）が立ち上がっておりますので、そちらを参考にしながら、Kaggle初心者向けのハンズオンチュートリアルを早速まとめました。

では、早速概要とシンプルな予測モデルをPythonを使って作ってみましょう！

Kaggleリクルート レストラン客数予測チャレンジ概要

まずは概要から紐解いていきましょう。英語が苦手な方向けの内容なので、問題ない方はRecruit Restaurant Visitor Forecastingをご覧ください。

• 2017年11月29日にKaggleリクルートチャレンジ（ホットペッパー）が開始
• 2018年1月30日が参加申し込みおよびチーム申請の最終期限
• 2018年2月6日が最終提出の締め切り
• 賞金は1位12,000米ドル、2位8,000米ドル、3位5,000米ドル
• 評価はRMSLEのスコア
• 提出ファイルはidとvisitorsの2カラム
  • idはair_store_idとvisit_dateをアンダースコアーで連結する
  • air_store_id以外にhpg(Hot Pepper Gourmet)のidもあるので要注意

蛇足ですが、リクルートが以前に行なったクーポン予測のコンペでは、賞金が1位30,000ドルでしたので、今回のコンペは賞金が半分以下になってしまいましたね。とはいえ、日系の会社からKaggleへの参加は嬉しいものです！日本人カグラーで上位を目指していきましょう！

それでは、Kaggleリクルートレストラン客数予測チャレンジの初心者向けハンズオンチュートリアルをやってみましょう。

このチュートリアルでやる内容＆対象の方

本記事ですがKaggleまたは機械学習初心者向けのチュートリアルとなっています。すでにKaggleで活躍されている方、機械学習を長年やっている方には物足りない内容となっていますので、ご注意ください。

このチュートリアルでやる内容

• Kaggleリクルートのデータセットの確認
• 色々な平均を出して予測をする（後ほど詳しくやります）
• Kaggleへファイルを提出（スコア確認）

使うもの

• Python 3.6
• Pandas
• Numpy
• Kaggleアカウント
• Jupyter Notebook（必須ではありません）

Jupyter Notebookですが、必須ではありません。Pythonのみを使って処理は可能ですが、あると便利です。多くのデーターサイエンティストが使っているツールですので、まだインストールされていない方は、この機会にいかがでしょうか？（ダウロードはこちらからどうぞ）

またPandasとNumpyのバージョンはさほど大きな影響はありませんが、Python2.7をお使いの方は、正しく処理できませんので3.6へのアップデートをご検討ください。

最後にデータを使うには、Kaggleリクルートコンペへの参加と利用規約の同意が必須となります。Kaggleの無料会員アカウントで可能なので、まだKaggleへ登録されていない方はこちらから登録をお願いします。

では、早速データをみていきましょう！

Kaggleリクルートのデータ確認

Kaggleリクルートチャレンジ2ではデータセットが全部で8つリクルートから提供されています。データは大きく分けると2種類あり、「ホットペッパー」と「Airレジ」の各サービスの2016年〜2017年4月までの予約情報（予約日時や予約人数）が提供されています。

• air_reserve.csv
  • Airレジ経由の予約情報
  • air_store_id – Airレジ固有のレストランID
  • visit_datetime – 予約時のお店訪問予定時間
  • reserve_datetime – 予約をした時の時間
  • reserve_visitors – 予約人数
• hpg_reserve.csv
  • ホットペッパー経由の予約情報
  • hpg_store_id – ホットペッパー固有のレストランID
  • visit_datetime – 予約時のお店訪問予定時間
  • reserve_datetime – 予約をした時の時間
  • reserve_visitors – 予約人数
• air_store_info.csv
  • Airレジのレストラン情報
  • air_store_id – Airレジ固有ID
  • air_genre_name – レストランのジャンル
  • air_area_name – レストランの所属エリア
  • latitude – 緯度
  • longitude – 経度
• hpg_store_info.csv
  • ホットペッパーのレストラン情報
  • hpg_store_id – ホットペッパー固有ID
  • air_genre_name – レストランのジャンル
  • air_area_name – レストランの所属エリア
  • latitude – 緯度
  • longitude – 経度
• store_id_relation.csv
  • AirレジとホットペッパーのIDリレーション
  • 両サービスを使っているお店のみ
  • hpg_store_id – ホットペッパー固有ID
  • air_store_id – Airレジ固有ID
• air_visit_data.csv
  • Airレジの各レストランの日付ごとの実客数
  • air_store_id – AirレジID
  • visit_date – 日付
  • visitors – 実客数
• sample_submission.csv
  • 提出ファイルのサンプルフィーマット
  • 予測しなくてはいけない日付も入っている
  • idの項目など少し特徴がある
  • id – air_store_idとvisit_dateを連結させたid
  • visitors – 予想客数（店＆日付のコンビネーション）
• data_info.csv
  • カレンダー日付の基本的な情報

ファイル数は多いですが、実際に予測に使える項目は思ったよりも少なさそうです。次に本チュートリアルでやる予測の手法をみていきましょう

Kaggleリクルート レストラン予測の手法

本チュートリアルですが、すでにKaggleで公開されているカーネルを参考に、初心者向けに書き直しています。公開されているコードとなりますので、当然ですがこちらの予測では100%上位ランクインできません！ただ、この予測を手始めに、色々な発展系を作るのはありだと思います。

早速、予測の手法をみていきましょう。

予測するデータ

これはsample_submission.csvを紐解くとわかりますが、予測しなくてはいけないデータは、Airレジを使っている821店舗のレストランの2017年4月最終週〜2017年5月末日までの各日にちのお客さん来店数となります。821店舗×39日間で32019行がsample_submission.csvに格納されています。全ての行のvisit（つまり来客数）を予測しなくてはいけません。

ステップ① 過去データの曜日の中央値（median）を算出

予測するレストランの過去の来客数データから、曜日ごとの中央値（median）を算出します。過去の来客数データはair_visit_data.csvに入っています。ただし、日付、レストランID、実客数のみしかありませんので、このデータに曜日を追加して、レストランIDと曜日毎に実客数をまとめて中央値（median）を算出します。

中央値（median）と平均値（mean）は似ていますが、異なりますので注意しましょう。簡単な説明ではありますが、下記のとあるレストランの月曜日〜水曜日の3週間分の来客数を見てください。

月曜日の平均値は25名で、中央値は25名とたまたま一緒でしたが、他の曜日では平均値と中央値は異なります。中央値は、データを並べたときに「真ん中」にある値をさします。今回のステップ1での予測では、この中央値（メディアン）を使います。

ステップ② 重み付き平均（加重平均）を算出

二つ目のステップとして、予測ターゲットを「重み付き平均」を使って算出します。まず簡単にですが、重み付き平均について説明をします。下記の表をまずご覧ください。

とある学校でAとBのクラスがあり、その平均点とクラスの人数を表しています。AとBのクラスの合わせた全体の平均点は82点となります。ただし、クラスの人数に差がありますので、人数が多いクラウスの方が重要（全体の平均点へ与える影響が大きい）と考えるのが加重平均の考え方です。

求め方としては各クラスの平均点にクラス人数をかけたものを足して、全体の人数で割ります。

最初の表に出ていますが、このようにクラスの人数＝重みをつけて改めて平均を計算すると、85.5点と算術平均と比べて高くなるのがわかります。

今回の予測ですが、複雑な計算は抜きにして、この重み平均も使ってみましょう。そもそもの議論として、どのような項目を使って「重み」を算出するのかは大きな議論となりますが、今回は単純にair_visit_data.csvの日付を重みとして利用します。前述しましたが、こちらのデータには2016年から2017年4月までの各店舗の実客数が日付ごとに入っています。

古い日付には重み（重要度）を低く、予測しなくはいけない2017年4月の直近のデータには重み（重要度）を高くします。

この重みを使って、各レストランの「曜日」「祝日フラグ」の項目にまとめて加重平均を算出します。意味合いとしては、「Aのレストランの祝日ではない火曜日は、過去1年間のデータで直近に重みをおいた加重平均で19名来店する可能性があります」という予測が可能です。

ステップ3 中央値と加重平均のさらに平均を算出

とうとうステップ3で、Kaggleへ提出する予測データを作ります。今まで2通りの方法で予測を算出してきましたが、最後の処理としてステップ1（中央値）とステップ2（加重平均）で算出した数値の、さらに平均をとって最終の予測データとしましょう。

Aをステップ1で求めた中央値（meadin）、Bをステップ2で求めた加重平均（wmean）とした時に、さらにその2つの数値の平均を下記の3つの異なる平均で求めてみましょう！

最後に求めた平均をCSVファイルへ書き出して、Kaggleへ投稿すればスコアもつきます！実際に3つの異なる平均で計算した予測データは、それが一番優秀なモデルなのか？も判明します。

では、実際にKaggleリクルートレストラン予測チャレンジからデータをダウロードして、Pythonを使って予測を計算してみましょう！

過去データの曜日の中央値を算出しよう

では、早速Pythonを使ってデータの処理と必要な値を算出していきましょう。またデータセットのCSVヲダウロードされていない方は、Kaggleへ無料会員登録を行いこちらからダウンロードしましょう。

まずは必要なライブラリをインポートしましょう。

# numpyなど必要なライブラリをインポート

import numpy as np
import pandas as pd 
import glob, re

次にsample_submission.csvを読み込んで確認してみましょう。

# sample_submission.csvを読みこんでヘッダー情報&Shapeの確認

test_df = pd.read_csv('sample_submission.csv')
test_df.head(20)
test_df.shape

(32019, 4)

sample_submission.csvですが、Kaggleへの提出データの形式となっています。こちらに入ってるAirレジのレストランと日付を使って、予測（実客数）の予測をしなくてはいけません。前の項目でも軽く触れましたがIDの形式がすこしややこしいですね。「air_ストアID_日付」と3つの情報がアンダースコアで連結されています。前処理として、このIDを情報毎に分解しましょう。

# 元々のIDからstore_idとvisit_dateを切り出します
test_df['store_id'] = test_df['id'].str[:20]
test_df['visit_date'] = test_df['id'].str[21:]

# 提出ファイルのサンプルでvisitorsは意味がないのでdropしましょう
test_df.drop(['visitors'], axis=1, inplace=True)

# 日付の型をobjectからdatetimeに変換しておきましょう
test_df['visit_date'] = pd.to_datetime(test_df['visit_date'])

# 念のためカラム情報の確認
test_df.info()

# ヘッダー情報もみておきましょう
test_df.head()

左がtest_dfのカラム情報で右がヘッダー情報となります。元々のIDに入っていたstore_idとvisit_dateを処理して別のカラムに分けました。visit_dateはdatetimeとして型の変更もしています。

次はair_visit_data.csvの読み込みと前処理をしましょう。air_visit_data.csvですが、Airレジの各レストランの日付と実客数のデータとなります。つまり予測しなくてはいけないレストランの過去の実客数の実績データです。このデータを処理してレストラン/曜日毎の「中央値（Median）」を算出しましょう。

# air_visit_data.csvを読み込む、parse_datesでdatetime型へ変換しておく
air_data = pd.read_csv('air_visit_data.csv', parse_dates=['visit_date'])

# サイズを確認しておきましょう
air_data.shape

(252108, 3)

# ヘッダー情報
air_data.head()

air_visit_data.csvは単純な構造ですね。visit_dateはdatetime型として扱えるようにparse_datesのアーギュメントを使いましょう。

予測で使うsample_submission.csvの中から一つだけレストランIDを取り出して、air_visit_data.csvのデータを参照してみましょう。今回はsample_submission.csvの最上部に載っていたID「air_00a91d42b08b08d9」を参照してみます。

# 予測するレストランIDを1つ使ってair_dataから実客数をみてみる
check_store_sample = air_data[air_data['air_store_id'] == 'air_00a91d42b08b08d9']

# 基本統計量の確認
check_store_sample.describe()

# visit_dateの確認
check_store_sample.visit_date.describe()

左がvisitorsの基本統計量、右がvisit_dateの情報となります。レストランID「air_00a91d42b08b08d9」では、平均26.0名、標準偏差12.43、最小1名〜最大99名のお客さんが来ていたことがわかります。右のvisit_dateを確認する通り、「2016年7月1日〜2017年4月22日」の期間のデータとなります。（こちらはデータセットの前処理ではありません。単純にデータがどうなっているのか確認のために出しました）

さて、本題に戻ってair_dataを訓練データとして使うために前処理を行なっていきましょう。前処理でやる事としては、主に下記の3つです。

• 2017-01-28以降のデータの切り出し
• visit_dateを基に曜日のデータ作成
• 曜日とレストランIDを基にグルーピングして中央値を算出

日付から曜日への変換ですが、pandasのdayofweekを使用して、dow（Day of Week）としてカラムに追加しています。dayofweekですが、曜日を文字列としてではなく数値（0=月曜日、6=日曜日）として出力しますので注意しましょう。

# air_dataの日付（visit_date）を曜日（dow）へ変換する
air_data['dow'] = air_data['visit_date'].dt.dayofweek

# air_dataから2017-01-28以降のデータを切り出して訓練データ「train」へ格納
train = air_data[air_data['visit_date'] > '2017-01-28'].reset_index()

# trainとtest_dfも日付を曜日へ変換して「dow」をカラム追加する
train['dow'] = train['visit_date'].dt.dayofweek
test_df['dow'] = test_df['visit_date'].dt.dayofweek

#データを確認しておきましょう
test_df.head()
train.head()

左がtrainで右がtest_dfのヘッダー情報です。両データ共に日付から変換された曜日（dow）が入っているのが確認できます。

さて、次はtrainからair_store_idとdowをグルーピングして、median（中央値）を取り出しましょう。

# pandasのagg関数で使うリストを作成
aggregation = {'visitors' : {'total_visitors' : 'median'}}

# trainからair_store_idとdowをグルーピングしてvisitorsの中央値（median）を算出
agg_data = train.groupby(['air_store_id', 'dow']).agg(aggregation).reset_index()

# agg_dataのカラム名をつける
agg_data.columns = ['air_store_id', 'dow', 'visitors']
agg_data['visitors']= agg_data['visitors']

# agg_dataを確認しよう
agg_data.head(12)

air_data（air_visit_data.csv）から各レストランIDごとに各曜日（dow）のお客さんの中央値のデータができました。こちらのデータですが、平均値（mean）ではなくて、中央値（median）ですので注意しましょう。

Kaggleへ提出するデータ（sample_submission.csv）から前処理したtest_dfと、各レストランの実客数データ（air_visit_data.csv）を処理して中央値を算出して作ったagg_dataをマージさせましょう。最後にfinalとして、Kaggleへの提出データに必要なidとvisitorsを切り取りましょう。

# test_dfとagg_dataのstoreid_id、dowをすり合わせmergeさせる
merged = pd.merge(test_df, agg_data, how='left', left_on=['store_id', 'dow'], right_on=['air_store_id', 'dow'])

# idとvisitorsだけをfinalへ格納
final = merged[['id', 'visitors']]

# finalのヘッダー情報
final.head()

元々のid（air_レストランID_日付）とagg_dataで処理したvisitors（レストランIDと曜日を基にair_visit_data.csvの実客数の中央値）だけ残しています。

上記のヘッドでも確認できますが、finalのデータの中にNaNが入っていますね。どれくらいNaNが入っているのか確認してみましょう。

# NaNを探してテーブルにする関数
def missing_values_table(df): 
        mis_val = df.isnull().sum()
        mis_val_percent = 100 * df.isnull().sum()/len(df)
        mis_val_table = pd.concat([mis_val, mis_val_percent], axis=1)
        mis_val_table_ren_columns = mis_val_table.rename(
        columns = {0 : 'Missing Values', 1 : '% of Total Values'})
        return mis_val_table_ren_columns 

# finalのNaNを確認してみよう
missing_values_table(final)

当然idは全て埋まっていますが、visitorsに1114個のNaNがあるのがわかります。全体の3.48%がNaNとなっています。これではまずいので・・こちらのNaNへ0を入れておきましょう。

# fillna関数を使ってvisitorsのNaNへ0を入れておく
final.fillna(0, inplace=True)

# 念のため確認
missing_values_table(final)

visitorsのカラムも全て何かしらの値が入ったことが確認できます。さて、ひとまずここまでで、予測しなくてはいけないAirレジレストランの各日付に対して、過去の曜日と実客数のデータから算出をした中央値を予測値としてもつデータができました。

次は、ステップ2として、、重み付き平均を算出しましょう。

重み付き平均（加重平均）を算出

ステップ2へ移る前に、他のCSVファイルもデータフレームに読み込んでしまいましょう。下記ですが、Kaggleリクルートチャレンジからダルロードしたファイルを同一フォルダーに入れていないと動きませんのでご注意ください。

# 全てのCSVを一気に読み込む
# glob.glob('')に適切なファイルのパスを指定してください
dfs = { re.search('/([^/\.]*)\.csv', fn).group(1):pd.read_csv(
    fn) for fn in glob.glob('./*.csv')}
for k, v in dfs.items(): locals()[k] = v

# 読み込んだファイルを確認
print('data frames read:{}'.format(list(dfs.keys())))

data frames read:['air_store_info', 'date_info', 'store_id_relation', 'hpg_reserve', 'air_reserve', 'air_visit_data', 'sample_submission', 'hpg_store_info']

これで各CSVファイルのファイル名＝データフレーム名として、読み込みが完了しました。前の項目で触れましたが、重み付き平均は「曜日」と「祝日フラグ」の項目別にまとめて出します。祝日ですが、リクルートから提供されているdata_info.csvを少し処理する必要があります。

まずはdate_infoを確認してみましょう。

# data_infoの祝日フラグが1（オン）のデータを確認
date_info[date_info['holiday_flg'] == 1].head(10)

index1とindex2のレコードを見るとわかりますが、祝日フラグには週末でも祝日の場合は「1」とフラグが立っているのがわかります。前処理として、まずはこちらのフラグを週末の場合（土曜日or日曜日）は、祝日であってもフラグを0とする処理を行いましょう。

# date_infoから土日で祝日フラグが「1」のレコードを探してweekend_hdaysに格納
weekend_hdays = date_info.apply((lambda x:(x.day_of_week=='Sunday' or x.day_of_week=='Saturday') and x.holiday_flg==1), axis=1)

# date_infoの該当の箇所のフラグを1から0へ更新をする
date_info.loc[weekend_hdays, 'holiday_flg'] = 0

これで祝日＝土日ではない平日のお休みというデータとなります。

次のステップとしては、日付を基に「重み」を作成しましょう。前述しましたが、日付が古いものには少ない重みを、予測する日付に近い（新しい日付）には多い重みを与えましょう。

# 該当の日付＋1　÷ 全部の日付の個数で重みを計算
# date_info.indexの値が小さい＝より昔のデータ
date_info['weight'] = (date_info.index + 1) / len(date_info) 

#ヘッダーとテイルの情報を出して確認してみよう
date_info.head()
date_info.tail()

左がheadで右がtailとなります。こちらの表で確認できる通り日付2016-01-01の重みは「0.001934」に対して、2017-05-31の重みは「1.000000」となっています。つまり予測しなくてはいけない日程に近いほど重要度が高いということが言えます。

重みの処理もできましたので、次のステップは実際に重み付き平均を算出することです。やり方としては、air_visit_data(Airレジの各レストランの実客数データ）に上記で算出したWeight（重み）を加えて、visitors（実客数）をnp.log1pを使って対数にして、「air_store_id」「day_of_week」「holiday_flg」（各レストランID、曜日、祝日フラグ）でグルーピングをして 重み付き平均を算出します。

# air_visit_dataと重みを追加したdate_infoをマージさせてvisit_dataを作成
# visit_dataから不必要なcalendar_dateを落とす
visit_data = air_visit_data.merge(date_info, left_on='visit_date', right_on='calendar_date', how='left')
visit_data.drop('calendar_date', axis=1, inplace=True)

# visit_dataの実客数にnp.log1pの対数関数を使って処理
visit_data['visitors'] = visit_data.visitors.map(pd.np.log1p)

# visit_dataの確認
visit_data.head(10)

上記の通り、事前に算出した「重み（weight）」、さらに実客数をnp.log1pで処理した数値が「visitors」へ処理が加わっているのが確認できます。

これで、やっと「レスストランID」「曜日」「祝日」に応じた重み付き平均の算出が可能になりました！本チュートリアルの前半で、重み付き平均の求め方をやっていますので、忘れてしまった方は改めて確認しておきましょう。

# wmean（重み付き平均）の式を格納
wmean = lambda x:( (x.weight * x.visitors).sum() / x.weight.sum() )


# グルーピングして重み付き平均を算出
visitors = visit_data.groupby(
    ['air_store_id', 'day_of_week', 'holiday_flg']).apply(wmean).reset_index()
visitors.rename(columns={0:'visitors'}, inplace=True) 

# データを確認
visitors.head(10)

これで、レストランID、曜日、祝日フラグごとの客数の「重み平均」が算出されました。上のヘッダー情報をみてもわかりますが、index1とindex2は同じレストランID「air_00a91d42b08b08d9」で曜日も「Monday（月曜日）」と一緒ですが、祝日フラグが異なりますので、各レコードに重み平均が算出されています。

さて、次の処理として、この重み付き平均で算出した予測客数を、sample_submissionのデータのレストランIDや日付を基に客数を埋めていきましょう。(sample_submissionに予測しなくてはいけない日付やレストランIDが入っていましたね）

# sample_submissionのIDをレストランIDや日付に分ける
sample_submission['air_store_id'] = sample_submission.id.map(
    lambda x: '_'.join(x.split('_')[:-1]))
sample_submission['calendar_date'] = sample_submission.id.map(lambda x: x.split('_')[2])

# 重み付き平均で予測したvisitorsとsample_submissionをマージする
sample_submission.drop('visitors', axis=1, inplace=True)
sample_submission = sample_submission.merge(date_info, on='calendar_date', how='left')
sample_submission = sample_submission.merge(
    visitors, on=['air_store_id', 'day_of_week', 'holiday_flg'], how='left')

# データセットを確認してみよう
sample_submission.head()

これで、事前に処理をした「重み付き平均」の客数が各レストラン毎に入りました。次に欠損データの確認と処理を行いましょう。まずは、欠損データをmissing_values_tableで確認してみましょう。

# sampe_submissionの欠損データを確認
missing_values_table(sample_submission)

visitorsで重み付き平均が入っていないレコードが668個もありますね。一番最初に重み付き平均を入れた時は過去データの「レストランID」「曜日」「祝日フラグ」に基づいて入れましたが、それに該当していないレコードが欠損していますので、今度は「祝日フラグ」の条件を除いて、「レストランID」「曜日」に基づいて重み付き平均を入れていきましょう。

# 「air_store_id」と「 day_of_week」のみで欠損データに重み平均を入れる
missings = sample_submission.visitors.isnull()
sample_submission.loc[missings, 'visitors'] = sample_submission[missings].merge(
    visitors[visitors.holiday_flg==0], on=(
        'air_store_id', 'day_of_week'), how='left')['visitors_y'].values

# 改めて欠損データの確認
missing_values_table(sample_submission)

上の条件で約200の欠損データが埋まりましたが、まだ448個あります。最後は「曜日」の条件も省いて、単純に「レストランID」にのみの重み付き平均を欠損データへ埋めておきましょう。

# 「air_store_id」のみの重み付き平均を計算して欠損データへ入れる
missings = sample_submission.visitors.isnull()
sample_submission.loc[missings, 'visitors'] = sample_submission[missings].merge(
    visitors[['air_store_id', 'visitors']].groupby('air_store_id').mean().reset_index(), 
    on='air_store_id', how='left')['visitors_y'].values

# 欠損データを確認
missing_values_table(sample_submission)

これで全ての欠損データが埋まったのが確認できます。

最後にこのsample_submissionをKaggleリクルートレストランチャレンジの提出規定の形に整えましょう。visitorsですが、現段階ではnp.log1pで対数となっていますので、np.expm1で実際の予測した客数に戻してから、カラムを規定のフォーマットに戻します。

# visitorsをnp.expm1で処理して実客数へ戻す
sample_submission['visitors'] = sample_submission.visitors.map(pd.np.expm1)

# 提出フォーマットの規定に合うように処理してsub_fileへ格納
sample_submission = sample_submission[['id', 'visitors']]
final['visitors'][final['visitors'] ==0] = sample_submission['visitors'][final['visitors'] ==0]
sub_file = final.copy()

# データの確認
sub_file.head()

これで、重み付き平均で予測をしたデータが「sub_file」としてKaggleへ提出データのフォーマットへ戻ったのが確認できます。次はとうとう最後のステップ「中央値と加重平均のさらに平均を算出」をして最終の予測データを出して、Kaggleでスコアを確認してみましょう。

中央値と加重平均のさらに平均を算出

現段階でfinaleのvisitorsへは、ステップ1で算出した「曜日の中央値 」が客数予測値として入っています。またsample_submissionのvisitorsへは、ステップ2で算出をした「重み付き平均」の客数予測値が入っています。

最後に、このふた通りの客数予測をさらに3つの手法で平均を算出してKaggleへデータを提出してみましょう。Aがfinal[‘visitors’]でBがsample_submission[‘visitors’]として、簡単に求めることが可能です。

各平均を求めて、それぞれ別名でcsvファイルに書き出しましょう。

# 算術平均をnp.meanで算出
sub_file['visitors'] = np.mean([final['visitors'], sample_submission['visitors']], axis = 0)
sub_file.to_csv('sub_math_mean_1.csv', index=False)

# 相乗平均を算出
sub_file['visitors'] = (final['visitors'] * sample_submission['visitors']) ** (1/2)
sub_file.to_csv('sub_geo_mean_1.csv', index=False)

# 調和平均を算出
sub_file['visitors'] = 2/(1/final['visitors'] + 1/sample_submission['visitors'])
sub_file.to_csv('sub_hrm_mean_1.csv', index=False)

ローカルに「sub_math_mean_1.csv」「sub_geo_mean_1.csv」「sub_hrm_mean_1.csv」の三つのファイルが出力されて入れば成功です。それでは、気になる予測の結果をKaggleへ投稿して確認してみましょう！

【結果】予測したファイルをKaggleへ投稿

Recruit Restaurant Visitor Forecasting Submitのページでファイルの提出が可能です。下記が、三つのファイルをKaggleへ提出した結果となります。Nameの部分が最後に出力したCSVファイル名となっています。

あまりスコアに大差はありませんが、どうやら最後の処理で「調和平均」で処理をした結果が一番良いスコアがでています。（つまり一番予測モデルとしての精度が優秀）参考までにですが、こちらのスコアは338名中の現在147位となっています！

Kaggleリクルートへ挑戦しよう

本チュートリアルでは、Kaggleリクルートチャレンジ2のデータを実際に触ってみて、Pythonを使って様々な平均を算出して予測をしました。

来年1月末までが最終提出の期限となっていますので、ぜひ、より精度の高い予測モデルの作成に挑んでみましょう！まだいまいちに不安な方は、他にもカーネルで多数の予測モデルが公開されています。カーネルを一つ一つ紐解くことで、データの前処理やモデリングなど参考になることは多くあります！

codexaでもKaggleのタイタニックや、メルカリチャレンジのハンズオンも同様に公開していますので、もう少し初心者向けハンズオンをやってみたいという方は、こちらも是非、やってみてください。

【Kaggle初心者入門編】タイタニック号で生き残るのは誰？

Kaggle メルカリ価格予想チャレンジの初心者チュートリアル

以上、Kaggleリクルートレストラン客数予測チャレンジの初心者向けチュートリアルでした！

私が記憶している限りだと、おそらく「リクルート」に次いで、日系企業として2社目かと思います！日本勢カグラーで上位を叩き出したいところではありますが、ひとまず最速レビューとして英語の苦手な方でも参加が可能なように、コンペの概要をまとめました。

また、ランダムフォレストを使って、既に複数のカーネル（コード）も公開されていましたので、機械学習初心者向けのハンズオンチュートリアルもまとめています。機械学習を勉強されている方は、これを機会にKaggleへの参加をしてみてはいかがでしょうか？

メルカリ 価格予測チャレンジ概要

Kaggleメルカリチャレンジでは、販売者が投稿した情報を基に「適正な販売価格」を予測するチャレンジです。訓練データとして、ユーザーが投稿した商品情報やカテゴリ、さらに商品の状態やブランド名などが与えられており、それらを基に販売価格を予測するモデル作成が課題です！

下記、Kaggleメルカリチャレンジの必要な概要情報まとめです。

• コンペ開始日は2017年11月21日
• エントリー締切日は2018年2月7日
• 課題提出締切日は2018年2月14日
• このチャレンジは「カーネルオンリー」（カーネルの提出をしないと評価されません）
• 現在公開されているデータ（Stage1）のカーネルを使ってStage2のデータ予測を行う
• チャレンジの最終ランキングはStage2のスコアが基準となる
• 賞金は1位60,000米ドル、2位30,000米ドル、3位10,000米ドル

まだ公開されて4日目と間もないですが、既に231チームが参加しています。現時点でのトップスコアは「0.44408」ですが、時間が経つにつれてスコアは改善されるかと！公開ランキングでは、既に日本人らしきお名前も数名見かけます！（頑張りましょう！！）

では、早速データの簡単な概要と、ランダムフォレストを使った初心者向けKaggleメルカリのハンズオンチュートリアルをやっていきましょう。

Kaggleメルカリ初心者向けチュートリアル概要

本チュートリアルは、機械学習初心者向けの内容となっています。既にKaggleへ参加しているデータサイエンティストの皆々様からは厳しいツッコミがありそうですが・・暖かい目で見守ってください。（笑）

チュートリアルで使うもの

• Python 3.X
• Pandas
• Numpy
• scikit-learn
• Jupyter Notebook（必須ではありません）

Python 2をお使いの方がいましたら、3を使うようにお願いします。それ以外のライブラリは、おそらくバージョンが多少違くても問題ないかと思います。

チュートリアルで行う内容

• Kaggleメルカリチャレンジのデータの確認
• データ事前処理
• ランダムフォレストのモデル作成
• 予測データのCSV書き出し
• Kaggleへの投稿

メルカリチャレンジの「Kernels」ページでは既にたくさんのランダムフォレストを使った予測モデルが公開されています。本チュートリアルでは、同様にランダムフォレストを使った予測を行います。Kaggleメルカリチャレンジへ投稿（Submit）すると「0.53」のスコアとなります。（11月25日時点で100位以内/231位）

参考までにですが、本チュートリアルはMac macOS High Sierra、メモリ 8GB、プロセッサ2.4GHz Core i5で、15分〜20分程度で処理が完了しました。

Kaggleメルカリのデータ確認

では、早速やってみましょう。まずは必要なものをインポートしておきましょう。

import pandas as pd
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from IPython.display import display
from sklearn import metrics
from sklearn.model_selection import train_test_split
pd.set_option('display.float_format', lambda x:'%.5f' % x)
import numpy as np

次にメルカリから提供されているトレーニングとテストデータを読み込みましょう。Kaggle Mercari Price Suggestion Challenge Dataのページからダウンロードが可能です。ダウンロードにはKaggleへの無料会員登録とコンペ参加規約への同意が必要ですので、まだ会員でない方は、まずはKaggleへの登録をしましょう。

メルカリから提供されているデータ形式ですが、「.7z」の形式となっています。Macをお使いの方は、「The Unarchiver」 で解凍が可能です。（無料でApp Storeより入手可能）

Kaggleからデータをダウンロードして解凍が出来たら、Pandasでデータフレームへ読み込みを行いましょう。

# データタイプを指定
types_dict_train = {'train_id':'int64', 'item_condition_id':'int8', 'price':'float64', 'shipping':'int8'}
types_dict_test = {'test_id':'int64', 'item_condition_id':'int8', 'shipping':'int8'}

# tsvファイルからPandas DataFrameへ読み込み
train = pd.read_csv('train.tsv', delimiter='\t', low_memory=True, dtype=types_dict_train)
test = pd.read_csv('test.tsv', delimiter='\t', low_memory=True, dtype=types_dict_test)

お決まりですが、ひとまずheadとshapeでデータのサイズと中身をチラ見してみましょう。

# trainとtestのデータフレームの冒頭5行を表示させる
train.head()
test.head()

# trainとtestのサイズを確認
train.shape, test.shape

((1482535, 9), (693359, 8))

trainの最初5行

testの最初5行

トレーニングデータは1,482,535個のユーザーが投稿した販売商品のデータセットとなっています。同様にテストデータは693,359個となりますが、「価格（Price）」の項目がテストデータは含まれていませんので列数は「8」となっています。

各データの情報を簡単にまとめました。

• train_id / test _id – ユーザー投稿のID
• name – 投稿のタイトル。タイトルに価格に関する情報がある場合（例：$20）はメルカリが事前に削除をして[rm]と置き換えています。
• item_condition_id – ユーザーが指定した商品の状態
• category_name – 投稿カテゴリー
• brand_name – ブランドの名前
• price – 訓練データのみ。実際に売られた価格。米ドル表示。今回のチャレンジの予測ターゲットとなります。
• shipping – 送料のフラグ。「1」は販売者負担。「0」は購入者負担。
• item_description – ユーザーが投稿した商品説明の全文。タイトルと同様に価格情報がある場合は[rm]と置き換えられています。

冒頭でも触れましたが、Kaggleメルカリチャレンジではこのダウンロードしたデータは「ステージ1」のデータとなります。実際にランキングの評価となるテストデータは、メルカリが新たに提供する「ステージ2」のデータです。（締切日までに投稿されたカーネルに自動的にステージ2のテストデータが提供されてスコアが算出されます）

次にデータの統計量を確認しましょう。Pandasの行と列の表示オプションを最大にして表示する「display_all」を作成して、trainとtestの統計量を確認します。「transpose」で列と行を転置しています。

def display_all(df):
    with pd.option_context("display.max_rows", 1000):
        with pd.option_context("display.max_columns", 1000):
            display(df)

# trainの基本統計量を表示
display_all(train.describe(include='all').transpose())

ふむふむ。「item_description」の「Top」では「No description yet」と出ていますね。商品説明がしっかり入っている訳ではなさそうですね。価格（price）は平均（mean）が26.74ドルで標準偏差（std)が38.59ドル。最小値が0ドル、最大値は2009ドルとなっています。一体、メルカリで2009ドルもの高価なものが売れているのに驚きが隠せませんが、それよりも最小値0ドルも気になります。

あんまり深追いすると進みませんので、サクサクと次にいきましょう！

次は、下記の4つの文字列を値として持っている項目を「category」のデータタイプへ変換をしましょう。

データタイプを文字列からcategoryへ変換する項目（trainとtestで同項目）

• category_name
• item_description
• name
• brand_name

# trainのカテゴリ名、商品説明、投稿タイトル、ブランド名のデータタイプを「category」へ変換する
train.category_name = train.category_name.astype('category')
train.item_description = train.item_description.astype('category')
train.name = train.name.astype('category')
train.brand_name = train.brand_name.astype('category')

# testのカテゴリ名、商品説明、投稿タイトル、ブランド名のデータタイプを「category」へ変換する
test.category_name = test.category_name.astype('category')
test.item_description = test.item_description.astype('category')
test.name = test.name.astype('category')
test.brand_name = test.brand_name.astype('category')

# dtypesで念のためデータ形式を確認しましょう
train.dtypes, test.dtypes

左がtranで右がtestです。指定した項目のデータ形式が「category」に変換されているのが確認できます。

次はデータのユニーク値を確認しておきましょう。

# trainの中のユニークな値を確認する
train.apply(lambda x: x.nunique())

# testの中のユニークな値を確認する
test.apply(lambda x: x.nunique())

左がtrainで右がtestのユニーク値の確認テーブル

当然ではありますが、train、test共にIDはしっかりとユニークな値となっています。カテゴリやブランド名の重複は当然ですが、投稿タイトル（name）にも重複データが結構ありますね。先に確認しましたが商品説明では「No Description yet」（商品説明がまだありません）があったので、こちらも重複があって当然ですね。

モデルを作成する前に必ずやらなくてはいけない作業、欠損データの確認もしておきましょう！

# trainの欠損データの個数と%を確認
train.isnull().sum(),train.isnull().sum()/train.shape[0]

# testの欠損データの個数と%を確認
test.isnull().sum(),test.isnull().sum()/test.shape[0]

左がtrainで右がtestです。最初に欠損データ数を表示して、次に欠損データの割合を表示しています

カテゴリ名（category_name）とブランド名（brand_name）は欠損数が大きいですね。ブランド名の欠損度合いはかなり大きいのも確認できます。データの簡単な確認も行えましたので、次からはデータの事前処理を行なっていきましょう。

Kaggleメルカリ データ事前処理

さて、ランダムフォレストのモデルを作成するためにデータの事前処理を行なっていきましょう。事前処理の流れとしては・・

1. trainとtestのデータを連結させる
2. 連結させたDataFrameの文字列のデータ形式を「cateogry」へ変換
3. 文字列を数値へ値を変換
4. 訓練用データの「price」をnp.log()で処理
5. ランダムフォレスト用にxとy（ターゲット）で分ける

ランダムフォレストのモデルを作るため、文字列のデータ（例：投稿タイトルやカテゴリ名など）をPandasの関数を使って一気に数値へと変換させます。そのため、testとtrainで別々に処理を行わず、連結して事前処理を行います。

文字列を数値へ変換したら、testとtrainへ改めて分けて、さらにランダムフォレスト作成のため、trainからターゲット（つまりprice）を分ける処理を行います。

文章で見ると・・いまいちパッとしませんので、実際にコードを見ていきましょう！

まずは、trainとtestのIDのカラム名を変更して、さらにデータ連結後でもどちらのデータに属しているかわかるようにフラグをつけておきましょう。

# trainとtestのidカラム名を変更する
train = train.rename(columns = {'train_id':'id'})
test = test.rename(columns = {'test_id':'id'})

# 両方のセットへ「is_train」のカラムを追加
# 1 = trainのデータ、0 = testデータ
train['is_train'] = 1
test['is_train'] = 0

# trainのprice(価格）以外のデータをtestと連結
train_test_combine = pd.concat([train.drop(['price'], axis=1),test],axis=0)

# 念のためデータの中身を表示させましょう
train_test_combine.head()

これで、trainとtestのデータの連結が「train_test_combine」に入りました。念のためshapeを確認すると「(2175894, 8)」と訓練データ1,482,535個とテストデータ693,359個の合計になっているのが確認できます。

次は、文字列のデータを数値へ変換しましょう。先に「train」と「test」を個別に文字列データの形式をcategoryに変換しましたが、同様に、連結させたデータ（train_test_combine）のデータ形式も変更をしましょう。

category形式に変換したら、pandasのcat.codesで数値へ変換を行います。

# train_test_combineの文字列のデータタイプを「category」へ変換
train_test_combine.category_name = train_test_combine.category_name.astype('category')
train_test_combine.item_description = train_test_combine.item_description.astype('category')
train_test_combine.name = train_test_combine.name.astype('category')
train_test_combine.brand_name = train_test_combine.brand_name.astype('category')

# combinedDataの文字列を「.cat.codes」で数値へ変換する
train_test_combine.name = train_test_combine.name.cat.codes
train_test_combine.category_name = train_test_combine.category_name.cat.codes
train_test_combine.brand_name = train_test_combine.brand_name.cat.codes
train_test_combine.item_description = train_test_combine.item_description.cat.codes

# データの中身とデータ形式を表示して確認しましょう
train_test_combine.head()
train_test_combine.dtypes

train_test_combineのヘッド情報

train_test_combineのdtypes

しっかりと文字列の値が数値へ変換されていますね。念のため表示したdtypesでも、objectからintへ変換されているのが確認できます。

数値へ変換が行えましたので、ここでtestとtrainへまた分けましょう。「is_train」（trainとtestのどちらに属するかを示すフラグ）は不要なので、この段階で落として、念のため、分け終わった後のtrain、testのデータフレームのサイズを確認しておきましょう。

# 「is_train」のフラグでcombineからtestとtrainへ切り分ける
df_test = train_test_combine.loc[train_test_combine['is_train'] == 0]
df_train = train_test_combine.loc[train_test_combine['is_train'] == 1]

# 「is_train」をtrainとtestのデータフレームから落とす
df_test = df_test.drop(['is_train'], axis=1)
df_train = df_train.drop(['is_train'], axis=1)

# サイズの確認をしておきましょう
df_test.shape, df_train.shape

((693359, 7), (1482535, 7))

さて、とうとう次でデータ事前処理の最後のステップとなります！無事に文字列→数値へ変換ができましたので、「df_train」（訓練データ）へ「train」の価格（price）を戻して、log関数で処理を行いましょう。

# df_trainへprice（価格）を戻す
df_train['price'] = train.price

# price（価格）をlog関数で処理
df_train['price'] = df_train['price'].apply(lambda x: np.log(x) if x>0 else x)

# df_trainを表示して確認
df_train.head()

カテゴリ名（category_name）や投稿タイトル（name）などがしっかりと数値に変換されているのが確認できます。参考までにですが、上記のheadのデータのbrand_nameでも確認できますが、文字列から数値へcat.codesへ変換した際に、異常値は「-1」として戻ります。

非常にシンプルなものですが、これでデータセットの事前処理は終わりました！次は、いよいよランダムフォレストのモデルをこのデータを使って作成していきましょう。

ランダムフォレストのモデル作成

もうここまで来れば、（気持ち的に）予測が完了したも同然です笑。では、処理をしたデータを使って、scikit-learnのRandomForestRegressorでモデルを作りましょう！

（処理完了までMac macOS High Sierra、メモリ 8GB、プロセッサ2.4GHz Core i5で、15分〜20分程度かかりました）

# x ＝ price以外の全ての値、y = price（ターゲット）で切り分ける
x_train, y_train = df_train.drop(['price'], axis=1), df_train.price

# モデルの作成
m = RandomForestRegressor(n_jobs=-1, min_samples_leaf=5, n_estimators=200)
m.fit(x_train, y_train)

# スコアを表示
m.score(x_train, y_train)

さぁ・・・・気になるスコアは・・・

となりました（笑）

モデルも作れましたので、先に処理を指定た「df_test」（テスト用データ）を入れて、実際の予測値を出しましょう。

予測値が出たら、指数関数（np.exp()）で処理をして、Pandasシリーズへ落とし込み、メルカリチャレンジの予測提出ファイル形式へ処理をしてCSVの書き出しを行いましょう！

# 作成したランダムフォレストのモデル「m」に「df_test」を入れて予測する
preds = m.predict(df_test)

# 予測値 predsをnp.exp()で処理
np.exp(preds)

# Numpy配列からpandasシリーズへ変換
preds = pd.Series(np.exp(preds))

# テストデータのIDと予測値を連結
submit = pd.concat([df_test.id, preds], axis=1)

# カラム名をメルカリの提出指定の名前をつける
submit.columns = ['test_id', 'price']

# 提出ファイルとしてCSVへ書き出し
submit.to_csv('submit_rf_base.csv', index=False)

自分のパソコンで処理を行なっていた方であれば、「submit_rf_base.csv」のファイルが書き出しされているかと思います。

今回のKaggleメルカリコンペですが、カーネルでのみ評価提出が可能なので、もしKaggleへ実際に投稿してみたい方は、Kaggleのカーネルへ上記コードを入れて提出をしましょう！

冒頭でもお話をしましたが、こちらの処理でスコア「0.53」となります。（11月25日時点で100位以内/231位）

まとめ

いかがでしたでしょうか？すでにKaggleメルカリチャレンジへ参加しているチームは日に日に増えており、さらに上位スコアも伸びてきています！

codexaでは日本でのカグラーのマッチングも行なっています！もし一人で参加するより、チームに参加して挑戦してみたいとお考えの方は、お問い合わせにてKaggleの公開プロフィールURLを記載してご連絡ください！スキルレベルが同等のメンバー様とマッチングいたします。

まだ機械学習を始めたばかりの方は、Kaggleタイタニックのチュートリアルもやってみてはいかがでしょうか？今回はランダムフォレストを使用しましたが、タイタニックでは「決定木」を使っています。

も間違いなどがありましたら・・コメント欄にてご指導・ご指摘をお願い致します！

この記事の概要と対象者

今回のKaggle紹介記事では、Kaggle初心者向けに公開されているデータセットを使って「タイタニックの生存者予測」をPythonを使って行います。Pythonはある程度使えるけど・・機械学習を触ったことが無い、とりあえず機械学習をやってみたい、という方に向けた記事です。（機械学習中〜上級者の方には、物足りない内容です）

このチュートリアルで使うもの

• Python 3.X
• Pandas
• Numpy
• scikit-learn

行う内容

• データセットの確認
• データセットの事前処理
• 「決定木」予測その1
• 「決定木」予測その2
• まとめ

Pythonを使ってデータを読み込むところから、実際に機械学習のモデルを作成・予測してKaggleへデータを投稿するところまで、手順をまとめています。ぜひ、ご自身のパソコンを使って同じ手順を踏んでみてください。

また、私は便宜上、jupyter notebookを使用しています。pythonを直接叩いても当然処理は可能ですが、プログラムの保存・共有も簡単ですし、「セルコーディング」と呼ばれるセル単位でメモやコーディングが可能なメリットもあります。機械学習をやっている肩であれば、使っている人も多いので、まだ導入されていない方がいれば、是非この機会にインストールしてみてください。

https://jupyter.readthedocs.io/en/latest/install.html （リンク先英語）

まずはデータセットの確認＆事前処理

機械学習では「データセットが9割の仕事を占める」と言われているくらい、データセットの確認や事前処理が非常に重要な意味合いを持ちます。では、実施にKaggleからデータをダウロードして、今回使うデータの内容を確認して行きましょう。

Kaggle無料会員登録＆CSVダウンロード

Kaggleの利用には無料会員登録が必要となります。まだアカウントをお持ちでいない方は、こちらから登録をしましょう。

登録が完了したら、Kaggleタイタニックのデータページへ移動をお願いします。こちらのページにて今回使う下記のCSVのダウロードをしましょう。

• train.csv （59.76 KB）
• test.csv（27.96 KB）

Kaggleタイタニックの課題ですが、実施のコンペティション（コンペ課題）とは異なり、Kaggle側が用意した機械学習初心者向けの課題となっています。ですので、提供されているデータも非常に作りは単純で、またファイルサイズも小さいことから、とても扱いやすいデータとなっています。

また、全て英語での説明となりますが、「Data」のページでは提供されているデータセットの詳細の説明も記載されています。コンペへ参加をする場合は、必ずこのDataページの説明を熟読しましょう。

CSVを読み込んで内容を確認しましょう

今回のチュートリアルではNumpyとPandasを使いますので、インポートをして、先ほどダウロードした「train.csv」と「test.csv」をデータフレーム形式で読み込みましょう。csvの格納先のディレクトリは各自、指定をしてから読み込みをしましょう。

import pandas as pd
import numpy as np

train = pd.read_csv("../ディレクトリを指定/train.csv")
test = pd.read_csv("../ディレクトリを指定/test.csv")

各csvに何が含まれているか、まずは確認をしてみましょう。

train.head()

Pandasのhead()を使うと、データフレームの最上部5段がデフォルトで表示されます。つまり、上の表は「train.csv」のカラム名と最上部5段の情報となります。各カラムの簡単な説明をは以下の通りです。

• PassengerId – 乗客識別ユニークID
• Survived – 生存フラグ（0=死亡、1=生存）
• Pclass – チケットクラス
• Name – 乗客の名前
• Sex – 性別（male=男性、female＝女性）
• Age – 年齢
• SibSp – タイタニックに同乗している兄弟/配偶者の数
• parch – タイタニックに同乗している親/子供の数
• ticket – チケット番号
• fare – 料金
• cabin – 客室番号
• Embarked – 出港地（タイタニックへ乗った港）

以上が訓練データとして提供されている項目となります。さらに各変数の簡単な説明も記載をしておきます。

pclass = チケットクラス

1 = 上層クラス（お金持ち）
2 = 中級クラス（一般階級）
3 = 下層クラス（労働階級）

Embarked = 各変数の定義は下記の通り

C = Cherbourg
Q = Queenstown
S = Southampton

では、次に test.csv も内容を簡単に確認してみましょう。

test.head()

こちらの test には、Survivedのカラムが無いのが確認できます。他のカラムは train と同様です。つまり、 train の乗客の情報と「Survived（生存したかどうか）」の答えを機械学習して、 test で提供されている乗客情報を元に、生存したか死亡したかの予測を作るのが課題ということです。

test_shape = test.shape
train_shape = train.shape

print(test_shape)
print(train_shape)

(418, 11)
(891, 12)

次にpandasのdescribe()を使って、各データセットの基本統計量も確認しておきましょう。

test.describe()
train.describe()

上記表の上が train で下が test の統計量情報となります。

各データのshapeを確認した通り、両データ共に「PassengerId」はTrain=891カウント、test＝418カウントと一致していますね。どうやら「Age」など一部のカラムでカウント数が少ない＝つまり欠損データがあるようです。

次は両データセットの欠損データを確認していきましょう。

データセットの欠損の確認

提供されている（または使う）データセットで100%データが揃っていることの方が珍しいくらいです。どこかのデータが欠損してたり、信用性が低いため使えなかったりする場合がほとんどです。

dataframeの欠損データをisnull()で探して、カラム毎に返す関数kesson_table()を作って、 train と test のデータフレームの欠損を確認しましょう。

def kesson_table(df): 
        null_val = df.isnull().sum()
        percent = 100 * df.isnull().sum()/len(df)
        kesson_table = pd.concat([null_val, percent], axis=1)
        kesson_table_ren_columns = kesson_table.rename(
        columns = {0 : '欠損数', 1 : '%'})
        return kesson_table_ren_columns

kesson_table(train)
kesson_table(test)

左が train で右が test の欠損データを表しています。思ったよりもしっかりとしたデータではありますが、特に「Age」と「Cabin」の2つの項目で欠損が多いですね。

では、欠損データを含めたデータの事前処理を次は行なっていきましょう！

データセットの事前処理

データセットの事前処理が一番重要ですが、今回はあくまでKaggle初心者向けチュートリアルですので、基本的なことを行なっていきます。このチュートリアルで行う内容としては・・

(1) 欠損データを代理データに入れ替える
(2) 文字列カテゴリカルデータを数字へ変換

の2つの事前処理を行なっていきましょう！

では、まずは欠損データへ代わりとなる代理データを入れていきましょう。

まずは train から綺麗にしていきましょう。先に確認しましたが、 train では「Age」「Embarked」「Cabin」の3カラムに欠損データがありましたね。今回のチュートリアルでは「Cabin」は予測モデルで使わないので、「Age」と「Embarked」の2つの欠損データを綺麗にしていきましょう。

まず「Age」ですが、シンプルに train の全データの中央値（Median）を代理として使いましょう。（代理データで何を使うか、どのような処理を加えるかは非常に重要かつ大きな議論ではありますが、ここはシンプルに考えて進めます）

次に「Embarked」（出港地）ですが、こちらも2つだけ欠損データが train に含まれています。他のデータを確認すると「S」が一番多い値でしたので、代理データとして「S」を使いましょう。

train["Age"] = train["Age"].fillna(train["Age"].median())
train["Embarked"] = train["Embarked"].fillna("S")


kesson_table(train)

各カラムでfillna()を使って代理となるデータを入れておきましょう。先ほど作ったkesson_table()で年のため欠損データがないかどうか確認をしましょう。Cabinは今回は使いませんので欠損データがあっても大丈夫ですが、「Age」「Embarked」の欠損は埋まりましたね。

trainの欠損データを代理データで埋めました

欠損データの処理が終わりましたので、次はカテゴリカルデータの文字列を数字に変換しましょう。今回の予想で使う項目で文字列を値として持っているカラムは「Sex」と「Embarked」の2種類となります。Sexは「male」「female」の2つのカテゴリー文字列、Embarkedはは「S」「C」「Q」の3つの文字列となります。これらを数字に変換しましょう。

train["Sex"][train["Sex"] == "male"] = 0
train["Sex"][train["Sex"] == "female"] = 1
train["Embarked"][train["Embarked"] == "S" ] = 0
train["Embarked"][train["Embarked"] == "C" ] = 1
train["Embarked"][train["Embarked"] == "Q"] = 2

train.head(10)

上記の通り、SexとEmbarkedに入っていた文字列の値が、数字へ変換されていることが確認できます。これで train の前処理は終わりましたが、次は test も同様の処理を行わないといけません。

test["Age"] = test["Age"].fillna(test["Age"].median())
test["Sex"][test["Sex"] == "male"] = 0
test["Sex"][test["Sex"] == "female"] = 1
test["Embarked"][test["Embarked"] == "S"] = 0
test["Embarked"][test["Embarked"] == "C"] = 1
test["Embarked"][test["Embarked"] == "Q"] = 2
test.Fare[152] = test.Fare.median()

test.head(10)

同様に「Age」へは中央値（Median）の代入、また文字列の値（AgeとEmbarked）は数字に変換しました。さらに、 test では、「Fare」に一つだけ欠損がありましたので、こちらも年齢と同様に中央値（Median）を代理で入れています。念のためhead()でデータの中身も確認をしておきましょう。

予測モデル その1 「決定木」

データの確認、事前処理も終わりましたので、とうとう本題の予測モデルを作って、実際に予測をしてみましょう！本記事では予測モデル「決定木」を異なるデータで訓練して、結果を比較してみようと思います。

「決定木」ですが、scikit-learnとNumpyを使えば非常に簡単に作成することが可能です。

まず初めに作る予測モデル「その1」ですが「Pclass」「Sex」「Age」「Fare」の4つの項目を使って「Survived（生存可否）」を予測してみましょう。別の言い方で表すと、タイタニックに乗船していた客の「チケットクラス（社会経済的地位）」「性別」「年齢」「料金」のデータを元に生存したか死亡したかを予測するとも言えます。

では実際に作ってみましょう。

まず、scikit-learnのインポートを行いましょう。

# scikit-learnのインポートをします
from sklearn import tree

# 「train」の目的変数と説明変数の値を取得
target = train["Survived"].values
features_one = train[["Pclass", "Sex", "Age", "Fare"]].values

# 決定木の作成
my_tree_one = tree.DecisionTreeClassifier()
my_tree_one = my_tree_one.fit(features_one, target)

# 「test」の説明変数の値を取得
test_features = test[["Pclass", "Sex", "Age", "Fare"]].values

# 「test」の説明変数を使って「my_tree_one」のモデルで予測
my_prediction = my_tree_one.predict(test_features)

まず決定木で使うTargetとFeatureの値を train から取得して格納しておきます。

次にscikit-learnの「DecisionTreeClassifier（）」を使って「my_tree_one」という決定木モデルを作成しました。

最後に事前に綺麗に処理をしておいた test から train で使ったFeatureと同様の項目の値を「test_features」へ入れて、predict()を使って予測をしました。

予測されたデータを確認してみましょう。

# 予測データのサイズを確認
my_prediction.shape

(418,)

#予測データの中身を確認
print(my_prediction)

予測をしなくてはいけないデータ数、つまり test のデータ数は418個でしたが、上記の通りmy_predictionも同じ数の予測数が結果として出力されていますね。今回の予測は「0か1（生存か死亡）」でしたが、念のため中身も確認してみると0と1で構成されているのが確認できます。

では、この予測データをCSVへ書き出してKaggleへ早速投稿してみましょう！下記のコードでPassengerIdと予測値を取得してCSVファイルを書き出します。

# PassengerIdを取得
PassengerId = np.array(test["PassengerId"]).astype(int)

# my_prediction(予測データ）とPassengerIdをデータフレームへ落とし込む
my_solution = pd.DataFrame(my_prediction, PassengerId, columns = ["Survived"])

# my_tree_one.csvとして書き出し
my_solution.to_csv("my_tree_one.csv", index_label = ["PassengerId"])

Python（またはJupyter Notebook）が立ち上がっている場所へ「my_tree_one.csv」が作成されていると思いますので、こちらのファイルをKaggleへ投稿してみましょう。

Kaggleへログインをしてタイタニックページへ移動をすると、上部メニュに「Submit Predictions」という項目がありますので、こちらをクリックしましょう。

同ページの下部にファイルアップローダーがありますので、こちらで先ほど書き出した「my_tree_one.csv」をアップロードして「Make Submission」をクリックしましょう。

投稿をすると次のページへ自動的に遷移します。さて、気になる結果ですが・・

ファイルがKaggleの投稿基準を満たしていると、即座にスコアを計算して表示してくれます。

「my_tree_one」は「チケットクラス（社会経済的地位）」「性別」「年齢」「料金」の4つのデータを用いて「決定木」のモデルを使い予測を行いましたが、結果として「0.71770」のスコアが獲得できました。

Kaggleのスコアはコンペにより異なります。各コンペの「Evaluation」のページに詳細が記載されています。今回予測を行なったタイタニックのコンペでは予測スコアは単純に「Accuracy（正解率）」が使われていますので、今作った「my_tree_one」は約71.8%の確率で正解を予測できましたということになります。

参考までにですが、Kaggleタイタニックのランキングを見てみると「0.71770」のスコアですと、約8600位前後となります。（＊このタイタニックの予測課題ですが、実は100%（つまりスコア1.0）を叩き出している強者データサイエンティストもいます。インターネットにその手法も公開されています。）

では、次はこの71.8%のスコアよりももう少し正確なモデルを作って見ましょう！

予測モデル その2 「決定木 + 7つの説明変数」

さて、予測モデルその1では「タイタニックに乗船していた客の「チケットクラス」「性別」「年齢」「料金」のデータを元に生存したか死亡したかを予測」しました。Kaggleで答え合わせをすると「約71.8%」の正解率でした。

では・・この正解率を上げるためにはどうすれば良いでしょうか？

少し考えて見てください

・・・

・・・

色々と試せることはあるかと思いますが、パッと思いつく限りだと、予測モデルの訓練で使うデータに他の変数も加味してみてはどうだろう？！と考えれますよね。

では、「その1」では4つのデータしか予測モデルに反映しませんでしがが、他で使えそうなデータも予測モデルに使って見ましょう！

映画「タイタニック」でも家族や子供と一緒に船から脱出を試みるシーンがあったように記憶してますが、これは恐らく生存確率に影響をしそうですよね。また出発港も3つのカテゴリしかありませんが、生存確率に何かしらの影響はあるのでは？と睨んで追加をしてみましょう。

まずはtrainのデータセットから今回追加になった項目の値も追加して「features_two」に取り出しましょう。

また、予測モデルその2では、簡単ではありますが「過学習（Overfitting）」についても考えて見ましょう。その1で作成した決定木のモデルではmax_depthとmin_samples_slitのアーギュメントを指定しませんでしたが、その2のモデルではアーギュメントを設定してみましょう。

# 追加となった項目も含めて予測モデルその2で使う値を取り出す
features_two = train[["Pclass","Age","Sex","Fare", "SibSp", "Parch", "Embarked"]].values

# 決定木の作成とアーギュメントの設定
max_depth = 10
min_samples_split = 5
my_tree_two = tree.DecisionTreeClassifier(max_depth = max_depth, min_samples_split = min_samples_split, random_state = 1)
my_tree_two = my_tree_two.fit(features_two, target)

さて、モデルの作成もできましたので、実際に「my_tree_two」を使って予測をしてみましょう。

# tsetから「その2」で使う項目の値を取り出す
test_features_2 = test[["Pclass", "Age", "Sex", "Fare", "SibSp", "Parch", "Embarked"]].values

# 「その2」の決定木を使って予測をしてCSVへ書き出す
my_prediction_tree_two = my_tree_two.predict(test_features_2)
PassengerId = np.array(test["PassengerId"]).astype(int)
my_solution_tree_two = pd.DataFrame(my_prediction_tree_two, PassengerId, columns = ["Survived"])
my_solution_tree_two.to_csv("my_tree_two.csv", index_label = ["PassengerId"])

上記のコードを正しく打ち込んでいれば、「my_tree_two.csv」として新しく作成した決定木による予測のCSVファイルが書き出されているはずです。

では、早速、Kaggleへ戻って結果をアップロードしてみましょう。

結果は・・スコア「0.76076」でした！つまり、正解確率が約76.0%とすこ〜しだけ改善されています。その１では正解率が約71.8%でしたので、訓練データを増やしたことにより約4%の改善ができました。

まとめ

今回の記事ではKaggle初心者編として、タイタニック号の乗客リストを使った生存予測を行ってみました。簡単な事前データ処理とScikit-learnの決定木を使うことで、思ったよりも簡単に機械学習に触れることが可能です。

英語ばかりで慣れないKaggleではありますが、機械学習を学ぶ人にとっては避けて通れないほど魅力が詰まっています。是非、これを機械にKaggleへの参加をしてみましょう。

codexaでは、機械学習初心者向けのチュートリアルや無料講座や有料チュートリアルも配信しています。Kaggleへ参加される前にPythonの機械学習系ライブラリの操作方法などを身につけてみましょう。

• スクラッチで最小二乗法と最急降下法をPythonでコーディング（線形回帰）
• ロジスティック回帰の概要や数学的理解と実践に役立つ知識（ロジスティック回帰）

また、まだ日本で機械学習などを周りにやっている人もごく少数で、気軽に相談や議論などをできる環境もなく、一人で悶々とひたすら勉強をしていたのですが・・

そんなあるときに、海外のサイトでデータを探していたら、「Kaggle」へ辿り着いたのです！そこは・・まるで・・機械学習を学んでいる当時の私には「天国」のような場所でした 。（今でも天国のような場所です）

今まで散々、お世話になって行きているKaggleですが、これから機械学習を勉強される方に向けた「Kaggleとは？Kaggle入門編」としてまとめていきたいと思います。

Kaggleとは？

まず呼び方ですが、Kaggleと書いて「カグル」と読みます。日本でも最近は定着してきましたが、Kaggleに参加している方を「カグラー（Kaggler）」とも呼びます。

Kaggleですが、本サイトへ行くと一番上に書かれていますが「The Home of Data Science & Machine Learning」（データサイエンスと機械学習の家）と題されている通り、世界中の機械学習・データサイエンスに携わっている約40万人の方が集まるコミニティーです。

Kaggleでは、企業や政府などの組織とデータ分析のプロであるデータサイエンティスト/機械学習エンジニアを繋げるプラットフォームとなっています。単純なマッチングではなく、Kaggleの最大の目玉とも言える「Competetion（コンペ）」がKaggleの特徴の一つです。

Competition（コンペ）は、企業や政府がコンペ形式（競争形式）で課題を提示し、賞金と引き換えに最も制度の高い分析モデルを買い取るという、最近でいう一種のクラウドファンディングに近いような仕組みとなります。

コンペの一例。

開催されるコンペは実に様々で、アメリカ国土安全保障省による空港のセキュリティースクリーニングの認識アルゴリズムの競争や、日本からだとメルカリによる販売者への自動価格提案アルゴリズムなどが開催されています。

また先述した通り、Kaggleに参加している人たちは無料でこれらのコンペに参加が可能で、企業から提供されているトレーニング用のデータセット（またそれに付随する様々なデータなどもある）を利用して、モデルの訓練を行い、さらにテストセットで評価までも可能です。

まだ機械学習を勉強し始めたばかりで…コンペなんて参加できないです…と思われている方もご安心ください！Kaggleでは初級者にも優しく設計されているのです。

初心者向けの一つの機能として「Kernels（カーネル）」があります。このカーネルでは、各データセットに対して他のユーザーが構築した予測モデルのコードや説明が公開されています。例えば、「このコンペのデータでは、XXXXの事前処理をデータセットに加えて、〇〇のモデルを使って予測したら、XXの精度が出たよ。これがコードだよ」という感じで、初心者にも優しく説明がされているカーネルも多数あります。（説明がなく単純にコードが公開されているケースもありますが）

また、「Discussion（ディスカッション）」では、世界中のデータサイエンティスト・機械学習実装者とのコミュニケーションも行えます。最新のモデリングの情報や、今までうまく行かなかったデータセットの処理方法など、最先端の現場の活きた知識／知恵が詰まっています！

では、実際にKaggle初心者の使い方のコツを詳しく見て行きましょう。

Kaggleコンペを覗こう/参加しよう

基本的にコンペへの参加条件などは特に設定はされておらず、無料会員登録を行えば、初心者でも誰でも参加が可能となります。ただし、ルールはコンペに応じて異なり、例えば使って良いデータの詳細やモデル構築時の環境の縛りなどがあります。

コンペのルールや条件などは全て英語で記載されていますので、簡単な英語の理解は必要です。加えて、さらに重要なのがデータセットの説明です。こちらも英語なのですが、各データが何を含んでいるのか、また各カラムやデータの質など、データセットの説明を抜きにコンペへ参加するのは難しいかと思います。

英語が苦手な方は、Google翻訳を使ってデータセットを紐解くか、検索をしてチュートリアルの記事を探す方法もあります。有名なコンペや練習データなどに対しては、日本語で解説されたチュートリアル記事もありますので、日本語で検索をしてみるのも一つの手段です。

• Kaggle メルカリ価格予想チャレンジの初心者チュートリアル
• 機械学習を使って630万件のレビューに基づいたアニメのレコメンド機能を作ってみよう（機械学習 k近傍法 初心者向け）
• ゲームソフトの売行きをXGBoostで予測してみた【Amazon SageMaker ノートブック＋モデル訓練＋モデルホスティングまで】
• Kaggle リクルートレストラン客数予想チャレンジをやってみた – Kaggle初心者ハンズオンチュートリアル
• 【Kaggle初心者入門編】タイタニック号で生き残るのは誰？

各コンペの利用規約へ同意をすると、データセットのダウロードが可能となります。データセットを落として、自分で処理を行い、最適な予測モデルを作って見ましょう！

予測モデルですが、各コンペの「 Evaluation 」のページにて「 Submission File 」（投稿ファイル）とう項目に形式や詳細がまとめられています。下記の例は現在進行中の「Mercari Price Suggestion Challenge」の評価詳細ページです。「 Submission File 」の項目に、「test_idとpriceの2列のヘッダーを含むCSV形式」で提出してくださいと指定があります。

予測モデルを作成して実際の予測をする場合は、提出ファイルの形式をしっかりと理解してから、予測を行いましょう。提出ファイルがルールに沿っていないと、正確に評価もされませんしスコアもつきません。

またコンペによっては、「Kernel Only」と指定がある場合もあります。この場合は、予測されたデータのファイルだけでなく、ファイルの事前処理を含む全てのモデルのコードのカーネルの提出が必要です。コンペに応じて、評価方法や提出物が異なりますので、取り組む前にしっかりと読みましょう。

予測データの投稿が完了すると、リアルタイムで評価がつきます！また予測データの投稿は1日5回までと制限があります。色々と試行錯誤をしながら投稿するので、この1日5回の制限によく引っかかります（汗）。

正しいデータフォーマットで予測データを投稿すると、「 Leaderboard 」へスコアと共に掲載されます。こちらのボードで、自分が構築した予測モデル/データがどれくらい優れているのかの確認が可能です！

先述した「アメリカ合衆国国土安全保障省」のコンペのリーダーボード

まだ機械学習を始めたばかりで…いきなりコンペに参加するのはハードルが高すぎる…という方は「Kanerl（カーネル）」でひたすら勉強をしましょう！次はKernelsの使い方について説明をして行きます。

Kaggle 初心者はひたすらカーネルをやるべし

色々なコンペを見て回ったけど・・まだ私にはレベルが高すぎて何をして良いかわからない・・！機械学習を触り始めの初心者の方であれば、Kaggleを使い出すと、そういう状況になることもあるかと思います。（私も最初はそうでした）

そんな初心者の方も安心してください！Kaggleの「Kernels（カーネル）」を使って見ましょう。Kernelsでは、先輩データサイエンティストさん達が構築したモデルやデータセット処理のコードが公開されています。各コンペまたはオープンデータセットに対してKernelsは用意されています。また言語でのフィルタリングも可能です。

下記のキャプチャですが、Mercariの販売価格予測チャレンジのカーネルとなります。リストの2番目の「Naive CatBoost」をご覧いただくとわかりやすいのですが、Jupyter Notebookの形式でCatBoostのモデルを利用した予測モデルのコードが公開されています。

このコードを自分の環境で書きながら、1ライン1ライン理解をしていくと良い勉強になります。なぜ、このような処理をしたのか？なぜこの項目を特徴量として使ったのか？などなどコードを真似しながら自分の中で噛み砕いていくことで、最先端のデータサイエンティストの考え方が身につけられます。

さらに、Kernels（カーネル）の嬉しいところは、実際に提出する予測ファイルまで完成できるところです。こちらの例のコードの全て処理すると、「0.60157」のスコアの予測データが出来上がります。（全てのカーネルが予測ファイルを生成できる訳ではありません）

参考までにですが、このCatBoostを使った予測モデルは11月22日時点で19位となっています。つまり、参加している予測モデルで19番目に精度が高いモデルを使って勉強が出来る訳です。

Mercariのコンペ以外にも、Kaggleでは多数のカーネルが公開されています。機械学習を始めたばかりで、データの処理の仕方がわからない、予測モデルも基本的なものの使い方しかわからないという方は、積極的にカーネルを勉強していきましょう！色々なデータセット、予測モデル、さらにはデータの前処理を行うことにより、経験と知識が増えていきます。

ディスカッションで積極的に質問しよう

さて、最後の3つ目のコツですが「ディスカッション」へ参加することです。これは最低限の英語スキルが必要となりますが、英語の自信のない方でもやるべきだと思います。なぜディスカッションに参加すべきなのか？を説明します。

Kaggleのディスカッションの大きなカテゴリです。一般的なフォーラムや技術的なQ&Aなど議論の内容に応じて別れています。

冒頭でもお話をしましたが、Kaggleはアメリカのみのサービスではありません。全世界の最先端のデータサイエンティストが集まるコミュニティーとなります。実際にディスカッションで投稿されている質問を見てみると、英語が必ずしも正しく書かれている訳ではありません。

自分の英語は完璧ではないから投稿に参加するのはちょっと…と思っている方でも、大丈夫です！そのような方もたくさんいますので、むしろ利用しない方が損です。また、自分は初心者だから・・質問の内容が拙いのでは？と考えるもの損です。Kaggleでは、初級者の方もたくさんいますし、実際に質問も初級から上級まで様々な質問/回答が投稿されているのが確認できます。

「自分は〇〇だから・・」と思う前に、まずはどっぷり、Kaggleのコミニティに浸りましょう！色々なスキルの方とコミュニケーションを取ることで、確実に自分の理解・スキルもアップします。

まとめ

全て英語のサービスというハードルはあるものの、データとコードは世界共通です。これから機械学習を学ぶ方、すでに学び始めている方はKaggleへ参加をすることで、機械学習/データサイエンスのスキルアップが出来ます。

codexaでは、機械学習初心者向けのチュートリアルや無料講座や有料チュートリアルも配信しています。Kaggleへ参加される前にPythonの機械学習系ライブラリの操作方法などを身につけてみましょう。

• スクラッチで最小二乗法と最急降下法をPythonでコーディング（線形回帰）
• ロジスティック回帰の概要や数学的理解と実践に役立つ知識（ロジスティック回帰）

• Numpy 入門
• Matplotlib 入門
• Pandas 入門
• 線形代数 入門
• 統計入門（前編）
• 統計入門（後編）
• 線形回帰 入門

以上となります！