ビッグデータ分析-概要

対処しなければならないデータの量は、過去10年間で想像を絶するレベルまで爆発的に増加し、同時にデータストレージの価格は体系的に低下しました。民間企業や研究機関は、ユーザーのインタラクション、ビジネス、ソーシャルメディア、および携帯電話や自動車などのデバイスからのセンサーに関するテラバイトのデータをキャプチャします。この時代の課題は、このデータの海を理解することです。ここで、*ビッグデータ分析*が登場します。

ビッグデータ分析では、主にさまざまなソースからデータを収集し、分析者が利用できるようにデータを変更し、最終的に組織のビジネスに役立つデータ製品を提供します。

ビジネス組織

さまざまなソースから取得した大量の非構造化生データを組織に役立つデータ製品に変換するプロセスは、ビッグデータ分析のコアを形成します。

ビッグデータ分析-データライフサイクル

従来のデータマイニングライフサイクル

組織が必要とする作業を整理し、ビッグデータから明確な洞察を提供するためのフレームワークを提供するには、さまざまな段階のサイクルと考えると便利です。それは決して線形ではありません。つまり、すべてのステージが相互に関連しています。このサイクルは、* CRISP方法論*で説明されている従来のデータマイニングサイクルと表面的に類似しています。

CRISP-DM方法論

データマイニングの業界共通プロセスの略である* CRISP-DM方法論は、データマイニングの専門家が従来のBIデータマイニングの問題に取り組むために使用する一般的に使用されるアプローチを説明するサイクルです。従来のBIデータマイニングチームでまだ使用されています。

次の図をご覧ください。 CRISP-DM方法論で説明されているサイクルの主要な段階と、それらの相互関係を示しています。

ライフサイクル

CRISP-DMは1996年と翌年に考案され、ESPRITの資金調達イニシアチブの下で欧州連合プロジェクトとして進行しました。このプロジェクトは、SPSS、Teradata、Daimler AG、NCR Corporation、OHRA（保険会社）の5社が主導しました。プロジェクトは最終的にSPSSに組み込まれました。この方法論は、データマイニングプロジェクトをどのように指定すべきかという点で非常に詳細に指向されています。

ここで、CRISP-DMのライフサイクルに関与する各段階についてもう少し学びましょう。

ビジネスの理解-この初期段階では、ビジネスの観点からプロジェクトの目的と要件を理解し、この知識をデータマイニングの問題定義に変換することに焦点を当てています。目標を達成するための予備計画が設計されています。意思決定モデル、特に意思決定モデルと表記標準を使用して構築されたものを使用できます。
データ理解-データ理解フェーズは、最初のデータ収集から始まり、データに精通し、データ品質の問題を特定し、データに対する最初の洞察を発見し、仮説を形成するために興味深いサブセットを検出するための活動に進みます隠された情報。
データの準備-データの準備段階では、最初の生データから最終的なデータセット（モデリングツールに入力されるデータ）を構築するためのすべてのアクティビティをカバーします。データ準備タスクは、規定の順序ではなく、複数回実行される可能性があります。タスクには、テーブル、レコード、および属性の選択のほか、モデリングツールのデータの変換とクリーニングが含まれます。
モデリング-このフェーズでは、さまざまなモデリング手法が選択および適用され、それらのパラメーターが最適な値に調整されます。通常、同じデータマイニング問題タイプにはいくつかの手法があります。一部の手法には、データの形式に関する特定の要件があります。そのため、多くの場合、データ準備フェーズに戻る必要があります。
評価-プロジェクトのこの段階では、データ分析の観点から、高品質であると思われるモデルを作成しました。モデルの最終的な展開に進む前に、モデルを徹底的に評価し、モデルを構築するために実行した手順を確認して、ビジネス目標が適切に達成されていることを確認することが重要です。 +重要な目的は、十分に検討されていない重要なビジネス上の問題があるかどうかを判断することです。このフェーズの終わりに、データマイニング結果の使用に関する決定に到達する必要があります。
展開-モデルの作成は一般的にプロジェクトの終わりではありません。モデルの目的がデータの知識を増やすことであったとしても、得られた知識は顧客にとって有益な方法で整理され提示される必要があります。 +要件に応じて、展開フェーズは、レポートを生成するのと同じくらい簡単な場合も、繰り返し可能なデータスコアリングを実装するのと同じくらい複雑な場合もありますセグメント割り当て）またはデータマイニングプロセス。

多くの場合、展開手順を実行するのはデータアナリストではなく顧客です。アナリストがモデルを展開した場合でも、作成されたモデルを実際に使用するために実行する必要があるアクションを事前に理解しておくことが重要です。

SEMMA方法論

SEMMAは、データマイニングモデリングのためにSASが開発した別の方法論です。 * S * ample、* E * xplore、* M * odify、* M * odel、* A * ssesを表します。ここにその段階の簡単な説明があります-

サンプル-プロセスはデータサンプリングから始まります。たとえば、モデリング用のデータセットを選択します。データセットは、取得するのに十分な情報を格納するのに十分な大きさである必要がありますが、効率的に使用するのに十分小さい必要があります。このフェーズでは、データのパーティション化も扱います。
探索-このフェーズでは、データの視覚化を活用して、変数間の異常な関係や異常を発見し、データの理解をカバーします。
変更-変更フェーズには、データモデリングの準備として変数を選択、作成、変換するメソッドが含まれます。
モデル-モデルフェーズでは、必要な結果を提供する可能性のあるモデルを作成するために、準備された変数にさまざまなモデリング（データマイニング）技術を適用することに焦点を当てています。
評価-モデリング結果の評価は、作成されたモデルの信頼性と有用性を示しています。

CRISM-DMとSEMMAの主な違いは、SEMMAがモデリングの側面に焦点を当てているのに対し、CRISP-DMは、解決するビジネス問題の理解、データの理解、前処理など、モデリングの前のサイクルの段階をより重視することです機械学習アルゴリズムなどの入力として使用されます。

ビッグデータのライフサイクル

今日のビッグデータのコンテキストでは、以前のアプローチは不完全または最適ではありません。たとえば、SEMMA方法論では、さまざまなデータソースのデータ収集と前処理を完全に無視します。通常、これらの段階は、成功するビッグデータプロジェクトのほとんどの作業を構成します。

ビッグデータ分析サイクルは、次の段階で説明することができます-

ビジネス問題の定義
研究
人事評価
データ収集
データ変更
データストレージ
探索的データ分析
モデリングと評価のためのデータ準備
モデリング
実装

このセクションでは、ビッグデータのライフサイクルのこれらの各段階に光を当てます。

ビジネス問題の定義

これは、従来のBIおよびビッグデータ分析のライフサイクルに共通するポイントです。通常、ビッグデータプロジェクトの問題を定義し、組織にとってどれだけの潜在的利益を得ることができるかを正しく評価することは、重要なプロジェクトの重要な段階です。これに言及するのは明らかなようですが、プロジェクトの期待される利益とコストを評価する必要があります。

研究

同じ状況で他の企業が行ったことを分析します。これには、会社が持っているリソースや要件に他のソリューションを適応させることを含め、会社にとって合理的なソリューションを探すことが含まれます。この段階では、将来の段階の方法論を定義する必要があります。

人事評価

問題が定義されたら、現在のスタッフがプロジェクトを正常に完了できるかどうかを分析し続けるのが妥当です。従来のBIチームは、すべての段階に最適なソリューションを提供できない可能性があるため、プロジェクトの一部を外部委託したり、より多くの人を雇用する必要がある場合は、プロジェクトを開始する前に検討する必要があります。

データ収集

このセクションは、ビッグデータのライフサイクルの鍵です。結果のデータ製品を配信するために必要なプロファイルのタイプを定義します。データ収集はプロセスの重要なステップです。通常、さまざまなソースから非構造化データを収集します。例として、クローラーを作成してWebサイトからレビューを取得することが含まれます。これには、通常、完了までにかなりの時間を要するさまざまな言語でのテキストの処理が含まれます。

データ変更

たとえば、Webからデータを取得したら、使いやすい形式で保存する必要があります。レビューの例を続けるために、データの表示が異なるサイトからデータが取得されると仮定します。

1つのデータソースが星の評価の観点からレビューを提供するとします。したがって、これを応答変数 y∈\ {1、2、3、4、5} のマッピングとして読み取ることができます。別のデータソースは、2つの矢印システムを使用してレビューを提供します。1つは上投票用、もう1つは下投票用です。これは、 y∈\ {positive、negative} という形式の応答変数を意味します。

両方のデータソースを結合するには、これら2つの応答表現を同等にするための決定を行う必要があります。これには、最初のデータソース応答表現を2番目の形式に変換することが含まれ、1つの星を負、5つの星を正と見なします。このプロセスでは、多くの場合、高品質で大きな時間の割り当てが必要になります。

データストレージ

データが処理されると、データベースに保存する必要がある場合があります。ビッグデータテクノロジーは、この点に関して多くの選択肢を提供します。最も一般的な代替方法は、HIVE Query Languageと呼ばれる限定バージョンのSQLをユーザーに提供するストレージにHadoopファイルシステムを使用することです。これにより、ユーザーの観点から、ほとんどの分析タスクを従来のBIデータウェアハウスで実行されるのと同様の方法で実行できます。考慮すべきその他のストレージオプションは、MongoDB、Redis、およびSPARKです。

サイクルのこの段階は、さまざまなアーキテクチャを実装する能力の観点から、人的資源の知識に関連しています。従来のデータウェアハウスの修正版は、大規模なアプリケーションでまだ使用されています。たとえば、テラデータとIBMは、テラバイトのデータを処理できるSQLデータベースを提供しています。 postgreSQLやMySQLなどのオープンソースソリューションは、大規模なアプリケーションで引き続き使用されています。

さまざまなストレージがバックグラウンドでどのように機能するかはクライアント側からは異なりますが、ほとんどのソリューションではSQL APIが提供されます。したがって、SQLを十分に理解することは、ビッグデータ分析に必要なスキルです。

この段階である_priori_は最も重要なトピックのようですが、実際にはこれは真実ではありません。必須の段階でもありません。リアルタイムデータを処理するビッグデータソリューションを実装することができます。そのため、この場合、データを収集してモデルを開発し、リアルタイムで実装するだけです。したがって、データを正式に保存する必要はまったくありません。

探索的データ分析

データをクリーンアップして、そこから洞察を取得できる方法で保存したら、データ探索フェーズは必須です。この段階の目的は、データを理解することです。これは通常、統計的手法とデータのプロットを使用して行われます。これは、問題の定義が意味を成すか実行可能かを評価するのに適した段階です。

モデリングと評価のためのデータ準備

この段階では、以前に取得したクリーンなデータを再形成し、欠損値の代入、外れ値の検出、正規化、特徴抽出、特徴選択に統計的な前処理を使用します。

モデリング

前の段階では、トレーニングやテスト用の複数のデータセット、たとえば予測モデルを作成しておく必要がありました。この段階では、さまざまなモデルを試して、目前のビジネス上の問題を解決することを楽しみにしています。実際には、モデルがビジネスに対する何らかの洞察を与えることが通常望まれます。最後に、最適なモデルまたはモデルの組み合わせを選択して、除外されたデータセットでのパフォーマンスを評価します。

実装

この段階では、開発されたデータ製品が会社のデータパイプラインに実装されます。これには、パフォーマンスを追跡するために、データ製品の動作中に検証スキームを設定することが含まれます。たとえば、予測モデルを実装する場合、この段階ではモデルを新しいデータに適用し、応答が利用可能になったらモデルを評価します。

ビッグデータ分析-方法論

方法論に関しては、ビッグデータ分析は、実験計画の従来の統計的アプローチとは大きく異なります。分析はデータから始まります。通常、応答を説明する方法でデータをモデル化します。このアプローチの目的は、応答の振る舞いを予測するか、入力変数が応答にどのように関係するかを理解することです。通常、統計実験計画では、実験が開発され、結果としてデータが取得されます。これにより、独立性、正規性、ランダム化などの特定の仮定が当てはまる統計モデルで使用できる方法でデータを生成できます。

ビッグデータ分析では、データが提示されます。お気に入りの統計モデルを満たす実験を設計することはできません。分析の大規模なアプリケーションでは、データをクリーンアップするためだけに大量の作業（通常は作業の80％）が必要になるため、機械学習モデルで使用できます。

実際の大規模アプリケーションで従うための独自の方法論はありません。通常、ビジネス上の問題が定義されたら、使用する方法論を設計するための調査段階が必要です。ただし、一般的なガイドラインは言及するのに適切であり、ほぼすべての問題に適用されます。

ビッグデータ分析で最も重要なタスクの1つは、統計モデリング*です。これは、教師付きおよび教師なしの分類または回帰の問題を意味します。データをクリーンアップして前処理し、モデリングに使用できるようになったら、適切な損失メトリックを使用してさまざまなモデルを評価し、モデルを実装したら、さらに評価と結果を報告する必要があります。予測モデリングの一般的な落とし穴は、モデルを実装するだけで、そのパフォーマンスを測定しないことです。

ビッグデータ分析-コア成果物

ビッグデータのライフサイクルで述べたように、ビッグデータ製品の開発から生じるデータ製品は、ほとんどの場合、次のいくつかです-

機械学習の実装-これは、分類アルゴリズム、回帰モデル、またはセグメンテーションモデルです。
推奨システム-目的は、ユーザーの行動に基づいて選択を推奨するシステムを開発することです。 Netflix は、このデータ製品の特徴的な例であり、ユーザーの評価に基づいて、他の映画が推奨されています。
ダッシュボード-ビジネスには通常、集計データを視覚化するツールが必要です。ダッシュボードは、このデータにアクセスできるようにするグラフィカルなメカニズムです。
アドホック分析-通常、ビジネスエリアには、データを使用したアドホック分析を行うことで回答できる質問、仮説、神話があります。

ビッグデータ分析-主要な利害関係者

大規模な組織では、ビッグデータプロジェクトを成功裏に開発するために、プロジェクトをバックアップする管理者が必要です。これには通常、プロジェクトのビジネス上の利点を示す方法を見つけることが含まれます。プロジェクトのスポンサーを見つける問題に対する独自の解決策はありませんが、いくつかのガイドラインを以下に示します-

興味のあるプロジェクトに似た他のプロジェクトのスポンサーは誰で、どこにいるかを確認してください。
主要な管理職に個人的な連絡先を置くことは役立ちます。そのため、プロジェクトが有望であれば、連絡先をトリガーできます。
あなたのプロジェクトの恩恵を受けるのは誰ですか？プロジェクトが順調に進んだら、クライアントは誰になりますか？
シンプルで明確な既存の提案を作成し、組織内の主要なプレーヤーと共有します。

プロジェクトのスポンサーを見つける最良の方法は、問題を理解し、実装後のデータ製品の結果を理解することです。この理解により、ビッグデータプロジェクトの重要性を管理者に納得させることができます。

ビッグデータ分析-データアナリスト

データアナリストはレポート指向のプロファイルを持ち、SQLを使用して従来のデータウェアハウスからデータを抽出および分析した経験があります。それらのタスクは通常、データストレージ側または一般的なビジネス結果のレポートのいずれかです。データウェアハウジングは決して単純なものではなく、データサイエンティストが行うこととはまったく異なります。

多くの組織は、市場で有能なデータサイエンティストを見つけるのに苦労しています。ただし、将来のデータアナリストを選択し、データサイエンティストになるための関連スキルを教えることをお勧めします。これは決して些細な仕事ではなく、通常は定量的な分野で修士号を取得する人が関与しますが、間違いなく実行可能なオプションです。有能なデータアナリストが持つ必要がある基本的なスキルを以下に示します-

ビジネス理解
SQLプログラミング
レポートの設計と実装
ダッシュボード開発

ビッグデータ分析-データサイエンティスト

データサイエンティストの役割は、通常、予測モデリング、セグメンテーションアルゴリズムの開発、レコメンダーシステム、A/Bテストフレームワークなどのタスクに関連付けられており、多くの場合、生の非構造化データの処理に使用されます。

彼らの仕事の性質は、数学、応用統計、プログラミングの深い理解を必要とします。データアナリストとデータサイエンティストの間で共通のスキルがいくつかあります。たとえば、データベースにクエリを実行する能力などです。どちらもデータを分析しますが、データサイエンティストの決定が組織に大きな影響を与える可能性があります。

これは、データサイエンティストが通常持つ必要があるスキルのセットです-

R、Python、SAS、SPSS、Juliaなどの統計パッケージでのプログラミング
さまざまなソースからデータをクリーンアップ、抽出、および探索できる
統計モデルの研究、設計、および実装
統計、数学、コンピューターサイエンスに関する深い知識

ビッグデータ分析では、人々は通常、データサイエンティストの役割とデータアーキテクトの役割を混同します。実際には、違いは非常に単純です。データアーキテクトは、データが保存されるツールとアーキテクチャを定義しますが、データサイエンティストはこのアーキテクチャを使用します。もちろん、データサイエンティストは、アドホックプロジェクトに必要な場合、新しいツールをセットアップできるはずですが、インフラストラクチャの定義と設計は彼のタスクの一部であってはなりません。

ビッグデータ分析-問題定義

このチュートリアルを通じて、プロジェクトを開発します。このチュートリアルの後続の各章では、ミニプロジェクトセクションの大きなプロジェクトの一部を扱います。これは、実世界の問題への露出を提供する応用チュートリアルセクションであると考えられます。この場合、プロジェクトの問題定義から始めます。

プロジェクトの説明

このプロジェクトの目的は、履歴書（CV）テキストを入力として使用して、人の時間給を予測する機械学習モデルを開発することです。

上記で定義したフレームワークを使用すると、問題を簡単に定義できます。 _X = \ {x〜1〜、x〜2〜、…、x〜n〜} _をユーザーの履歴書として定義できます。各機能は、可能な限り簡単な方法で、この単語が表示される回数です。。その後、応答は真に価値があり、個人の時間給をドルで予測しようとしています。

これらの2つの考慮事項は、提示された問題を教師付き回帰アルゴリズムで解決できると結論付けるのに十分です。

問題定義

問題の定義*は、おそらくビッグデータ分析パイプラインの中で最も複雑で無視されている段階の1つです。データ製品が解決する問題を定義するには、経験が必須です。ほとんどのデータサイエンティスト志望者は、この段階でほとんどまたはまったく経験がありません。

ほとんどのビッグデータの問題は、次の方法で分類することができます-

教師付き分類
教師付き回帰
教師なし学習
ランク付けを学ぶ

これらの4つの概念について詳しく説明しましょう。

教師付き分類

特徴マトリックス_X = \ {x〜1〜、x〜2〜、…、x〜n〜} _が与えられた場合、モデルMを開発して、_y = \ {c〜1〜、cとして定義されるさまざまなクラスを予測します。〜2〜、…、c〜n〜} _。例：保険会社の顧客のトランザクションデータを指定すると、クライアントが解約するかどうかを予測するモデルを開発できます。後者はバイナリ分類の問題で、2つのクラスまたはターゲット変数があります：チャーンとチャーンではありません。

他の問題には複数のクラスの予測が関係するため、数字認識を行うことに興味があるため、応答ベクトルは次のように定義されます。_y = \ {0、1、2、3、4、5、6、7、8、9 } _、最先端のモデルは畳み込みニューラルネットワークであり、特徴のマトリックスは画像のピクセルとして定義されます。

教師あり回帰

この場合、問題の定義は前の例とかなり似ています。違いは応答に依存します。回帰問題、応答y∈ℜでは、これは応答が実数値であることを意味します。たとえば、CVのコーパスを与えられた個人の時間給を予測するモデルを開発できます。

教師なし学習

多くの場合、経営陣は新しい洞察を渇望しています。セグメンテーションモデルは、マーケティング部門がさまざまなセグメントの製品を開発するために、この洞察を提供できます。アルゴリズムを考えるのではなく、セグメンテーションモデルを開発するための適切なアプローチは、必要なセグメンテーションに関連する機能を選択することです。

たとえば、電気通信会社では、クライアントを携帯電話の使用量でセグメント化することは興味深いです。これには、セグメンテーションの目的とは関係のない機能を無視し、関係する機能のみを含めることが含まれます。この場合、これは1か月に使用されるSMSの数、インバウンドおよびアウトバウンドの分数などの機能を選択することになります。

ランク付けを学ぶ

この問題は回帰問題と見なすことができますが、特定の特性があり、別の扱いが必要です。この問題には、クエリが与えられたときに最も関連性の高い順序を見つけようとするドキュメントのコレクションが含まれます。教師あり学習アルゴリズムを開発するには、クエリが与えられた場合に、順序がどの程度関連しているかをラベル付けする必要があります。

教師あり学習アルゴリズムを開発するには、トレーニングデータにラベルを付ける必要があることに注意してください。これは、たとえば、画像からの数字を認識するモデルをトレーニングするために、かなりの量の例に手でラベルを付ける必要があることを意味します。このプロセスを高速化することができ、amazon Mechanical Turkなどのこのタスクに一般的に使用されるWebサービスがあります。より多くのデータが提供されると、学習アルゴリズムのパフォーマンスが向上することが証明されているため、適切な量の例にラベルを付けることは、教師あり学習では実際に必須です。

ビッグデータ分析-データ収集

データ収集は、ビッグデータサイクルで最も重要な役割を果たします。インターネットは、さまざまなトピックのほぼ無制限のデータソースを提供します。この分野の重要性はビジネスの種類によって異なりますが、従来の業界では外部データの多様なソースを取得し、それらをトランザクションデータと組み合わせることができます。

たとえば、レストランを推奨するシステムを構築したいとします。最初のステップは、さまざまなWebサイトからレストランのレビュー（この場合はレビュー）を収集し、データベースに保存することです。生のテキストに興味があり、それを分析に使用するため、モデルを開発するためのデータがどこに保存されるかは関係ありません。これは、ビッグデータのメインテクノロジーと矛盾するように聞こえるかもしれませんが、ビッグデータアプリケーションを実装するには、リアルタイムで動作させる必要があります。

Twitter Miniプロジェクト

問題が定義されたら、次の段階はデータを収集することです。次のミニプロジェクトのアイデアは、Webからデータを収集し、それを構造化して機械学習モデルで使用できるようにすることです。 Rプログラミング言語を使用して、twitter rest APIからいくつかのツイートを収集します。

まず、Twitterアカウントを作成してから、 twitteR パッケージhttp://geoffjentry.hexdump.org/twitteR.pdf[vignette]の指示に従ってtwitter開発者アカウントを作成します。これはそれらの指示の要約です-

https://twitter.com/apps/newにアクセスしてログインします。
基本情報を入力したら、[設定]タブに移動して[ダイレクトメッセージの読み取り、書き込み、アクセス]を選択します。
これを行った後、保存ボタンをクリックしてください
[詳細]タブで、コンシューマキーとコンシューマシークレットをメモします
Rセッションでは、APIキーとAPIシークレット値を使用します
最後に、次のスクリプトを実行します。これにより、githubのリポジトリから twitteR パッケージがインストールされます。

install.packages(c("devtools", "rjson", "bit64", "httr"))

# Make sure to restart your R session at this point
library(devtools)
install_github("geoffjentry/twitteR")

文字列 "big mac"が含まれるデータを取得し、この点で際立っているトピックを見つけることに興味があります。これを行うための最初のステップは、twitterからデータを収集することです。以下は、twitterから必要なデータを収集するRスクリプトです。このコードは、bda/part1/collect_data/collect_data_twitter.Rファイルでも入手できます。

rm(list = ls(all = TRUE)); gc() # Clears the global environment
library(twitteR)
Sys.setlocale(category = "LC_ALL", locale = "C")

### Replace the xxx’s with the values you got from the previous instructions

# consumer_key = "xxxxxxxxxxxxxxxxxxxx"
# consumer_secret = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# access_token = "xxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# access_token_secret= "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# Connect to twitter rest API
setup_twitter_oauth(consumer_key, consumer_secret, access_token, access_token_secret)

# Get tweets related to big mac
tweets <- searchTwitter(’big mac’, n = 200, lang = ’en’)
df <- twListToDF(tweets)

# Take a look at the data
head(df)

# Check which device is most used
sources <- sapply(tweets, function(x) x$getStatusSource())
sources <- gsub("</a>", "", sources)
sources <- strsplit(sources, ">")
sources <- sapply(sources, function(x) ifelse(length(x) > 1, x[2], x[1]))
source_table = table(sources)
source_table = source_table[source_table > 1]
freq = source_table[order(source_table, decreasing = T)]
as.data.frame(freq)

#                       Frequency
# Twitter for iPhone       71
# Twitter for Android      29
# Twitter Web Client       25
# recognia                 20

ビッグデータ分析-クレンジングデータ

データが収集されると、通常、さまざまな特性を持つ多様なデータソースが得られます。最も直接的なステップは、これらのデータソースを同種にし、データ製品の開発を継続することです。ただし、データの種類によって異なります。データを均質化することが実際的かどうかを自問する必要があります。

データソースは完全に異なる可能性があり、ソースが均質化されると情報の損失が大きくなる可能性があります。この場合、代替案を考えることができます。 1つのデータソースで回帰モデルを作成し、もう1つのデータソースで分類モデルを作成できますか？単に情報を失うのではなく、私たちの利点に基づいて異質性を扱うことは可能ですか？これらの決定を下すことは、分析を面白くやりがいのあるものにします。

レビューの場合、各データソースに言語を設定することができます。繰り返しますが、我々は2つの選択肢があります-

均質化-さまざまな言語をより多くのデータがある言語に翻訳することを伴います。翻訳サービスの品質は許容範囲内ですが、APIを使用して大量のデータを翻訳したい場合、コストは非常に高くなります。このタスクに使用できるソフトウェアツールがありますが、それもコストがかかります。
異化-各言語の解決策を開発することは可能でしょうか？コーパスの言語を検出するのは簡単なので、各言語のレコメンダーを開発できます。これには、使用可能な言語の量に応じて各リコメンダーを調整するという点でより多くの作業が含まれますが、使用可能な言語がいくつかある場合は間違いなく実行可能なオプションです。

Twitter Miniプロジェクト

このケースでは、まず非構造化データをクリーンアップしてから、データモデリングにトピックを適用するためにデータマトリックスに変換する必要があります。一般に、Twitterからデータを取得する場合、少なくともデータクレンジングプロセスの最初の段階では、使用することに興味のない文字がいくつかあります。

たとえば、ツイートを取得すると、「<ed> <U + 00A0> <U + 00BD> <ed> <U + 00B8> <U + 008B>」という奇妙な文字が表示されます。これらはおそらく顔文字なので、データを消去するために、次のスクリプトを使用してそれらを削除します。このコードは、bda/part1/collect_data/cleaning_data.Rファイルでも入手できます。

rm(list = ls(all = TRUE)); gc() # Clears the global environment
source('collect_data_twitter.R')
# Some tweets
head(df$text)

[1] "I’m not a big fan of turkey but baked Mac &
cheese <ed><U+00A0><U+00BD><ed><U+00B8><U+008B>"
[2] "@Jayoh30 Like no special sauce on a big mac. HOW"
### We are interested in the text - Let’s clean it!

# We first convert the encoding of the text from latin1 to ASCII
df$text <- sapply(df$text,function(row) iconv(row, "latin1", "ASCII", sub = ""))

# Create a function to clean tweets
clean.text <- function(tx) {
  tx <- gsub("htt.{1,20}", " ", tx, ignore.case = TRUE)
  tx = gsub("[^#[:^punct:]]|@|RT", " ", tx, perl = TRUE, ignore.case = TRUE)
  tx = gsub("[[:digit:]]", " ", tx, ignore.case = TRUE)
  tx = gsub(" {1,}", " ", tx, ignore.case = TRUE)
  tx = gsub("^\\s+|\\s+$", " ", tx, ignore.case = TRUE)
  return(tx)
}

clean_tweets <- lapply(df$text, clean.text)

# Cleaned tweets
head(clean_tweets)
[1] " WeNeedFeminlsm MAC s new make up line features men woc and big girls "
[1] " TravelsPhoto What Happens To Your Body One Hour After A Big Mac "

データクレンジングミニプロジェクトの最終ステップは、マトリックスに変換してアルゴリズムを適用できるテキストをクリーンアップすることです。 clean_tweets ベクトルに保存されたテキストから、それを単語の袋マトリックスに簡単に変換し、教師なし学習アルゴリズムを適用できます。

ビッグデータ分析-データの要約

レポートは、ビッグデータ分析で非常に重要です。すべての組織は、意思決定プロセスをサポートするために定期的に情報を提供する必要があります。このタスクは通常、SQLおよびETL（抽出、転送、ロード）の経験を持つデータアナリストによって処理されます。

このタスクを担当するチームは、ビッグデータ分析部門で作成された情報を組織のさまざまな領域に広める責任があります。

次の例は、データの要約の意味を示しています。 bda/part1/summarize_data フォルダーに移動し、フォルダー内で summarize_data.Rproj ファイルをダブルクリックして開きます。次に、 summarize_data.R スクリプトを開き、コードを見て、表示される説明に従ってください。

# Install the following packages by running the following code in R.
pkgs = c('data.table', 'ggplot2', 'nycflights13', 'reshape2')
install.packages(pkgs)

*ggplot2* パッケージは、データの視覚化に最適です。 *data.table* パッケージは、 *R* で高速かつメモリ効率の高い要約を行うための優れたオプションです。 最近のベンチマークでは、同様のタスクに使用されるpythonライブラリである *pandas* よりもさらに高速であることが示されています。

ベンチマーク

次のコードを使用してデータを見てください。このコードは bda/part1/summarize_data/summarize_data.Rproj ファイルでも利用できます。

library(nycflights13)
library(ggplot2)
library(data.table)
library(reshape2)

# Convert the flights data.frame to a data.table object and call it DT
DT <- as.data.table(flights)

# The data has 336776 rows and 16 columns
dim(DT)

# Take a look at the first rows
head(DT)

#   year    month  day   dep_time  dep_delay  arr_time  arr_delay  carrier
# 1: 2013     1     1      517       2         830         11       UA
# 2: 2013     1     1      533       4         850         20       UA
# 3: 2013     1     1      542       2         923         33       AA
# 4: 2013     1     1      544      -1        1004        -18       B6
# 5: 2013     1     1      554      -6         812        -25       DL
# 6: 2013     1     1      554      -4         740         12       UA

#     tailnum  flight  origin   dest    air_time   distance    hour   minute
# 1:  N14228   1545     EWR      IAH      227        1400       5       17
# 2:  N24211   1714     LGA      IAH      227        1416       5       33
# 3:  N619AA   1141     JFK      MIA      160        1089       5       42
# 4:  N804JB    725     JFK      BQN      183        1576       5       44
# 5:  N668DN    461     LGA      ATL      116        762        5       54
# 6:  N39463   1696     EWR      ORD      150        719        5       54

次のコードには、データの要約の例があります。

### Data Summarization
# Compute the mean arrival delay
DT[, list(mean_arrival_delay = mean(arr_delay, na.rm = TRUE))]
#        mean_arrival_delay
# 1:           6.895377
# Now, we compute the same value but for each carrier
mean1 = DT[, list(mean_arrival_delay = mean(arr_delay, na.rm = TRUE)),
   by = carrier]
print(mean1)
#      carrier    mean_arrival_delay
# 1:      UA          3.5580111
# 2:      AA          0.3642909
# 3:      B6          9.4579733
# 4:      DL          1.6443409
# 5:      EV         15.7964311
# 6:      MQ         10.7747334
# 7:      US          2.1295951
# 8:      WN          9.6491199
# 9:      VX          1.7644644
# 10:     FL         20.1159055
# 11:     AS         -9.9308886
# 12:     9E          7.3796692
# 13:     F9         21.9207048
# 14:     HA         -6.9152047
# 15:     YV         15.5569853
# 16:     OO         11.9310345

# Now let’s compute to means in the same line of code
mean2 = DT[, list(mean_departure_delay = mean(dep_delay, na.rm = TRUE),
   mean_arrival_delay = mean(arr_delay, na.rm = TRUE)),
   by = carrier]
print(mean2)

#       carrier    mean_departure_delay   mean_arrival_delay
# 1:      UA            12.106073          3.5580111
# 2:      AA             8.586016          0.3642909
# 3:      B6            13.022522          9.4579733
# 4:      DL             9.264505          1.6443409
# 5:      EV            19.955390         15.7964311
# 6:      MQ            10.552041         10.7747334
# 7:      US             3.782418          2.1295951
# 8:      WN            17.711744          9.6491199
# 9:      VX            12.869421          1.7644644
# 10:     FL            18.726075         20.1159055
# 11:     AS             5.804775         -9.9308886
# 12:     9E            16.725769          7.3796692
# 13:     F9            20.215543         21.9207048
# 14:     HA             4.900585         -6.9152047
# 15:     YV            18.996330         15.5569853
# 16:     OO            12.586207         11.9310345

### Create a new variable called gain
# this is the difference between arrival delay and departure delay
DT[, gain:= arr_delay - dep_delay]

# Compute the median gain per carrier
median_gain = DT[, median(gain, na.rm = TRUE), by = carrier]
print(median_gain)

ビッグデータ分析-データ探索

探索的データ分析*は、ジョン・タッキー（1977）によって開発された概念であり、統計の新しい観点に基づいています。 Tuckeyの考えは、従来の統計では、データはグラフィカルに探索されておらず、仮説をテストするためだけに使用されていたというものでした。ツールを開発する最初の試みはスタンフォードで行われ、プロジェクトはhttp://stat-graphics.org/movies/prim9l[prim9]と呼ばれました。このツールは、9次元でデータを視覚化できたため、データの多変量の観点を提供できました。

近年、探索的データ分析は必須であり、ビッグデータ分析のライフサイクルに含まれています。洞察を見つけて組織内で効果的に伝達できる能力は、強力なEDA機能によって強化されます。

Tuckeyのアイデアに基づいて、Bell Labsは統計を行うためのインタラクティブなインターフェースを提供するために* Sプログラミング言語*を開発しました。 Sのアイデアは、使いやすい言語で広範なグラフィカル機能を提供することでした。今日の世界では、ビッグデータのコンテキストでは、 S プログラミング言語に基づいた R が分析用の最も一般的なソフトウェアです。

上位分析パッケージ

次のプログラムは、探索的データ分析の使用方法を示しています。

以下は、探索的データ分析の例です。このコードは、 part1/eda/exploratory_data_analysis.R ファイルでも利用できます。

library(nycflights13)
library(ggplot2)
library(data.table)
library(reshape2)

# Using the code from the previous section
# This computes the mean arrival and departure delays by carrier.
DT <- as.data.table(flights)
mean2 = DT[, list(mean_departure_delay = mean(dep_delay, na.rm = TRUE),
   mean_arrival_delay = mean(arr_delay, na.rm = TRUE)),
   by = carrier]

# In order to plot data in R usign ggplot, it is normally needed to reshape the data
# We want to have the data in long format for plotting with ggplot
dt = melt(mean2, id.vars = ’carrier’)

# Take a look at the first rows
print(head(dt))

# Take a look at the help for ?geom_point and geom_line to find similar examples
# Here we take the carrier code as the x axis
# the value from the dt data.table goes in the y axis

# The variable column represents the color
p = ggplot(dt, aes(x = carrier, y = value, color = variable, group = variable)) +
   geom_point() + # Plots points
   geom_line() + # Plots lines
   theme_bw() + # Uses a white background
   labs(list(title = 'Mean arrival and departure delay by carrier',
      x = 'Carrier', y = 'Mean delay'))
print(p)

# Save the plot to disk
ggsave('mean_delay_by_carrier.png', p,
   width = 10.4, height = 5.07)

コードは、次のような画像を生成する必要があります-

平均遅延

ビッグデータ分析-データの可視化

データを理解するために、それを視覚化することがしばしば役立ちます。通常、ビッグデータアプリケーションでは、関心は単に美しいプロットを作成するのではなく、洞察を見つけることに依存しています。以下は、プロットを使用してデータを理解するためのさまざまなアプローチの例です。

フライトデータの分析を開始するには、数値変数間に相関関係があるかどうかを確認することから始めます。このコードは bda/part1/data_visualization/data_visualization.R ファイルでも利用できます。

# Install the package corrplot by running
install.packages('corrplot')

# then load the library
library(corrplot)

# Load the following libraries
library(nycflights13)
library(ggplot2)
library(data.table)
library(reshape2)

# We will continue working with the flights data
DT <- as.data.table(flights)
head(DT) # take a look

# We select the numeric variables after inspecting the first rows.
numeric_variables = c('dep_time', 'dep_delay',
   'arr_time', 'arr_delay', 'air_time', 'distance')

# Select numeric variables from the DT data.table
dt_num = DT[, numeric_variables, with = FALSE]

# Compute the correlation matrix of dt_num
cor_mat = cor(dt_num, use = "complete.obs")

print(cor_mat)
### Here is the correlation matrix
#              dep_time   dep_delay   arr_time   arr_delay    air_time    distance
# dep_time   1.00000000  0.25961272 0.66250900  0.23230573 -0.01461948 -0.01413373
# dep_delay  0.25961272  1.00000000 0.02942101  0.91480276 -0.02240508 -0.02168090
# arr_time   0.66250900  0.02942101 1.00000000  0.02448214  0.05429603  0.04718917
# arr_delay  0.23230573  0.91480276 0.02448214  1.00000000 -0.03529709 -0.06186776
# air_time  -0.01461948 -0.02240508 0.05429603 -0.03529709  1.00000000  0.99064965
# distance  -0.01413373 -0.02168090 0.04718917 -0.06186776  0.99064965  1.00000000

# We can display it visually to get a better understanding of the data
corrplot.mixed(cor_mat, lower = "circle", upper = "ellipse")

# save it to disk
png('corrplot.png')
print(corrplot.mixed(cor_mat, lower = "circle", upper = "ellipse"))
dev.off()

このコードは、次の相関行列の可視化を生成します-

相関

プロットでは、データセット内のいくつかの変数間に強い相関関係があることがわかります。たとえば、到着遅延と出発遅延は非常に相関しているようです。これは、楕円が両方の変数の間でほぼ直線的な関係を示しているためにわかりますが、この結果から因果関係を見つけることは簡単ではありません。

2つの変数が相関しているため、一方が他方に影響を与えるとは言えません。また、プロットでは、飛行時間と距離の間に強い相関関係があることがわかります。これは、飛行距離が長くなると、飛行時間が長くなるため、かなり合理的です。

データの単変量解析を行うこともできます。分布を視覚化する簡単で効果的な方法は、ボックスプロット*です。次のコードは、ggplot2ライブラリを使用して箱ひげ図と格子図を作成する方法を示しています。このコードは *bda/part1/data_visualization/boxplots.R ファイルでも利用できます。

source('data_visualization.R')
### Analyzing Distributions using box-plots
# The following shows the distance as a function of the carrier

p = ggplot(DT, aes(x = carrier, y = distance, fill = carrier)) + # Define the carrier
   in the x axis and distance in the y axis
   geom_box-plot() + # Use the box-plot geom
   theme_bw() + # Leave a white background - More in line with tufte's
      principles than the default
   guides(fill = FALSE) + # Remove legend
   labs(list(title = 'Distance as a function of carrier', # Add labels
      x = 'Carrier', y = 'Distance'))
p
# Save to disk
png(‘boxplot_carrier.png’)
print(p)
dev.off()

# Let's add now another variable, the month of each flight
# We will be using facet_wrap for this
p = ggplot(DT, aes(carrier, distance, fill = carrier)) +
   geom_box-plot() +
   theme_bw() +
   guides(fill = FALSE) +
   facet_wrap(~month) + # This creates the trellis plot with the by month variable
   labs(list(title = 'Distance as a function of carrier by month',
      x = 'Carrier', y = 'Distance'))
p
# The plot shows there aren't clear differences between distance in different months

# Save to disk
png('boxplot_carrier_by_month.png')
print(p)
dev.off()

ビッグデータ分析-Rの概要

このセクションでは、ユーザーにRプログラミング言語を紹介します。 Rはhttps://cran.r-project.org/[cran website]からダウンロードできます。 Windowsユーザーの場合、https://cran.r-project.org/bin/windows/Rtools/[install rtools]およびhttps://www.rstudio.com/[rstudio IDE]が役立ちます。

*R* の背後にある一般的な概念は、C、C ++、Fortranなどのコンパイル言語で開発された他のソフトウェアへのインターフェイスとして機能し、データを分析するための対話型ツールをユーザーに提供することです。

ブックのzipファイル bda/part2/R_introduction のフォルダーに移動し、 R_introduction.Rproj ファイルを開きます。これにより、RStudioセッションが開きます。次に、01_vectors.Rファイルを開きます。スクリプトを1行ずつ実行し、コード内のコメントに従ってください。学習するための別の便利なオプションは、コードを入力するだけです。これは、R構文に慣れるのに役立ちます。 Rでは、コメントは＃記号で記述されます。

ブックでRコードを実行した結果を表示するために、コードが評価された後、Rが返す結果にコメントが付けられます。このようにして、コードをコピーして本に貼り付け、Rでそのセクションを直接試すことができます。

# Create a vector of numbers
numbers = c(1, 2, 3, 4, 5)
print(numbers)

# [1] 1 2 3 4 5
# Create a vector of letters
ltrs = c('a', 'b', 'c', 'd', 'e')
# [1] "a" "b" "c" "d" "e"

# Concatenate both
mixed_vec = c(numbers, ltrs)
print(mixed_vec)
# [1] "1" "2" "3" "4" "5" "a" "b" "c" "d" "e"

前のコードで何が起こったのか分析しましょう。数字と文字でベクトルを作成できることがわかります。事前にどのタイプのデータ型が必要かをRに伝える必要はありませんでした。最後に、数字と文字の両方を含むベクターを作成できました。ベクトルmixed_vecは数値を文字に強制しました。これは、引用符内で値がどのように印刷されるかを視覚化することで確認できます。

次のコードは、関数クラスによって返されるさまざまなベクトルのデータ型を示しています。クラス関数を使用してオブジェクトに「問い合わせ」を行い、自分のクラスが何であるかを尋ねることが一般的です。

### Evaluate the data types using class

### One dimensional objects
# Integer vector
num = 1:10
class(num)
# [1] "integer"

# Numeric vector, it has a float, 10.5
num = c(1:10, 10.5)
class(num)
# [1] "numeric"

# Character vector
ltrs = letters[1:10]
class(ltrs)
# [1] "character"

# Factor vector
fac = as.factor(ltrs)
class(fac)
# [1] "factor"

Rは2次元オブジェクトもサポートします。次のコードには、Rで使用される2つの最も一般的なデータ構造の例があります：matrixとdata.frameです。

# Matrix
M = matrix(1:12, ncol = 4)
#      [,1] [,2] [,3] [,4]
# [1,]    1    4    7   10
# [2,]    2    5    8   11
# [3,]    3    6    9   12
lM = matrix(letters[1:12], ncol = 4)
#     [,1] [,2] [,3] [,4]
# [1,] "a"  "d"  "g"  "j"
# [2,] "b"  "e"  "h"  "k"
# [3,] "c"  "f"  "i"  "l"

# Coerces the numbers to character
# cbind concatenates two matrices (or vectors) in one matrix
cbind(M, lM)
#     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
# [1,] "1"  "4"  "7"  "10" "a"  "d"  "g"  "j"
# [2,] "2"  "5"  "8"  "11" "b"  "e"  "h"  "k"
# [3,] "3"  "6"  "9"  "12" "c"  "f"  "i"  "l"

class(M)
# [1] "matrix"
class(lM)
# [1] "matrix"

# data.frame
# One of the main objects of R, handles different data types in the same object.
# It is possible to have numeric, character and factor vectors in the same data.frame

df = data.frame(n = 1:5, l = letters[1:5])
df
#   n l
# 1 1 a
# 2 2 b
# 3 3 c
# 4 4 d
# 5 5 e

前の例で示したように、同じオブジェクトで異なるデータ型を使用することが可能です。一般に、これはデータがデータベースでどのように表示されるかであり、データのAPI部分はテキストまたは文字ベクトルと他の数値です。 Inは、割り当てる統計データ型を決定し、それに適切なRデータ型を使用するアナリストの仕事です。統計では、通常、変数は次のタイプであると考えます-

数値
名義またはカテゴリー
序数

Rでは、ベクトルは次のクラスになります-

数値-整数
因子
順序付けられた因子

Rは、変数の統計タイプごとにデータタイプを提供します。ただし、順序付けられた因子はめったに使用されませんが、関数因子によって作成されるか、順序付けられます。

次のセクションでは、インデックス付けの概念を扱います。これは非常に一般的な操作であり、オブジェクトのセクションを選択して変換する問題を処理します。

# Let's create a data.frame
df = data.frame(numbers = 1:26, letters)
head(df)
#      numbers  letters
# 1       1       a
# 2       2       b
# 3       3       c
# 4       4       d
# 5       5       e
# 6       6       f

# str gives the structure of a data.frame, it’s a good summary to inspect an object
str(df)
#   'data.frame': 26 obs. of  2 variables:
#   $ numbers: int  1 2 3 4 5 6 7 8 9 10 ...
#   $ letters: Factor w/26 levels "a","b","c","d",..: 1 2 3 4 5 6 7 8 9 10 ...

# The latter shows the letters character vector was coerced as a factor.
# This can be explained by the stringsAsFactors = TRUE argumnet in data.frame
# read ?data.frame for more information

class(df)
# [1] "data.frame"

### Indexing
# Get the first row
df[1, ]
#     numbers  letters
# 1       1       a

# Used for programming normally - returns the output as a list
df[1, , drop = TRUE]
# $numbers
# [1] 1
#
# $letters
# [1] a
# Levels: a b c d e f g h i j k l m n o p q r s t u v w x y z

# Get several rows of the data.frame
df[5:7, ]
#      numbers  letters
# 5       5       e
# 6       6       f
# 7       7       g

### Add one column that mixes the numeric column with the factor column
df$mixed = paste(df$numbers, df$letters, sep = ’’)

str(df)
# 'data.frame': 26 obs. of  3 variables:
# $ numbers: int  1 2 3 4 5 6 7 8 9 10 ...
# $ letters: Factor w/26 levels "a","b","c","d",..: 1 2 3 4 5 6 7 8 9 10 ...
# $ mixed  : chr  "1a" "2b" "3c" "4d" ...

### Get columns
# Get the first column
df[, 1]
# It returns a one dimensional vector with that column

# Get two columns
df2 = df[, 1:2]
head(df2)

#      numbers  letters
# 1       1       a
# 2       2       b
# 3       3       c
# 4       4       d
# 5       5       e
# 6       6       f

# Get the first and third columns
df3 = df[, c(1, 3)]
df3[1:3, ]

#      numbers  mixed
# 1       1     1a
# 2       2     2b
# 3       3     3c

### Index columns from their names
names(df)
# [1] "numbers" "letters" "mixed"
# This is the best practice in programming, as many times indeces change, but
variable names don’t
# We create a variable with the names we want to subset
keep_vars = c("numbers", "mixed")
df4 = df[, keep_vars]

head(df4)
#      numbers  mixed
# 1       1     1a
# 2       2     2b
# 3       3     3c
# 4       4     4d
# 5       5     5e
# 6       6     6f

### subset rows and columns
# Keep the first five rows
df5 = df[1:5, keep_vars]
df5

#      numbers  mixed
# 1       1     1a
# 2       2     2b
# 3       3     3c
# 4       4     4d
# 5       5     5e

# subset rows using a logical condition
df6 = df[df$numbers < 10, keep_vars]
df6

#      numbers  mixed
# 1       1     1a
# 2       2     2b
# 3       3     3c
# 4       4     4d
# 5       5     5e
# 6       6     6f
# 7       7     7g
# 8       8     8h
# 9       9     9i

ビッグデータ分析-SQLの概要

SQLは、構造化照会言語の略です。これは、従来のデータウェアハウスおよびビッグデータテクノロジーのデータベースからデータを抽出するために最も広く使用されている言語の1つです。 SQLの基本を示すために、例を使って作業します。言語自体に焦点を合わせるために、R内でSQLを使用します。 SQLコードの記述に関しては、これはデータベースで行われるのとまったく同じです。

SQLのコアは、SELECT、FROM、およびWHEREの3つのステートメントです。次の例では、SQLの最も一般的な使用例を使用しています。 bda/part2/SQL_introduction フォルダーに移動し、 SQL_introduction.Rproj ファイルを開きます。次に、01_select.Rスクリプトを開きます。 RでSQLコードを作成するには、次のコードに示すように sqldf パッケージをインストールする必要があります。

# Install the sqldf package
install.packages('sqldf')

# load the library
library('sqldf')
library(nycflights13)

# We will be working with the fligths dataset in order to introduce SQL

# Let’s take a look at the table
str(flights)
# Classes 'tbl_d', 'tbl' and 'data.frame': 336776 obs. of  16 variables:

# $ year     : int  2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 ...
# $ month    : int  1 1 1 1 1 1 1 1 1 1 ...
# $ day      : int  1 1 1 1 1 1 1 1 1 1 ...
# $ dep_time : int  517 533 542 544 554 554 555 557 557 558 ...
# $ dep_delay: num  2 4 2 -1 -6 -4 -5 -3 -3 -2 ...
# $ arr_time : int  830 850 923 1004 812 740 913 709 838 753 ...
# $ arr_delay: num  11 20 33 -18 -25 12 19 -14 -8 8 ...
# $ carrier  : chr  "UA" "UA" "AA" "B6" ...

# $ tailnum  : chr  "N14228" "N24211" "N619AA" "N804JB" ...
# $ flight   : int  1545 1714 1141 725 461 1696 507 5708 79 301 ...
# $ origin   : chr  "EWR" "LGA" "JFK" "JFK" ...
# $ dest     : chr  "IAH" "IAH" "MIA" "BQN" ...
# $ air_time : num  227 227 160 183 116 150 158 53 140 138 ...
# $ distance : num  1400 1416 1089 1576 762 ...
# $ hour     : num  5 5 5 5 5 5 5 5 5 5 ...
# $ minute   : num  17 33 42 44 54 54 55 57 57 58 ...

selectステートメントは、テーブルから列を取得し、それらに対して計算を行うために使用されます。最も簡単なSELECTステートメントは、 ej1 で示されています。 ej2 に示すように、新しい変数を作成することもできます。

### SELECT statement
ej1 = sqldf("
   SELECT
   dep_time
   ,dep_delay
   ,arr_time
   ,carrier
   ,tailnum
   FROM
   flights
")

head(ej1)
#    dep_time   dep_delay  arr_time  carrier  tailnum
# 1      517         2      830      UA       N14228
# 2      533         4      850      UA       N24211
# 3      542         2      923      AA       N619AA
# 4      544        -1     1004      B6       N804JB
# 5      554        -6      812      DL       N668DN
# 6      554        -4      740      UA       N39463

# In R we can use SQL with the sqldf function. It works exactly the same as in
a database

# The data.frame (in this case flights) represents the table we are querying
and goes in the FROM statement
# We can also compute new variables in the select statement using the syntax:

# old_variables as new_variable
ej2 = sqldf("
   SELECT
   arr_delay - dep_delay as gain,
   carrier
   FROM
   flights
")

ej2[1:5, ]
#    gain   carrier
# 1    9      UA
# 2   16      UA
# 3   31      AA
# 4  -17      B6
# 5  -19      DL

SQLで最もよく使用される機能の1つは、group byステートメントです。これにより、別の変数の異なるグループの数値を計算できます。スクリプト02_group_by.Rを開きます。

### GROUP BY

# Computing the average
ej3 = sqldf("
  SELECT
   avg(arr_delay) as mean_arr_delay,
   avg(dep_delay) as mean_dep_delay,
   carrier
   FROM
   flights
   GROUP BY
   carrier
")

#    mean_arr_delay   mean_dep_delay carrier
# 1       7.3796692      16.725769      9E
# 2       0.3642909       8.586016      AA
# 3      -9.9308886       5.804775      AS
# 4       9.4579733      13.022522      B6
# 5       1.6443409       9.264505      DL
# 6      15.7964311      19.955390      EV
# 7      21.9207048      20.215543      F9
# 8      20.1159055      18.726075      FL
# 9      -6.9152047       4.900585      HA
# 10     10.7747334      10.552041      MQ
# 11     11.9310345      12.586207      OO
# 12      3.5580111      12.106073      UA
# 13      2.1295951       3.782418      US
# 14      1.7644644      12.869421      VX
# 15      9.6491199      17.711744      WN
# 16     15.5569853      18.996330      YV

# Other aggregations
ej4 = sqldf("
   SELECT
   avg(arr_delay) as mean_arr_delay,
   min(dep_delay) as min_dep_delay,
   max(dep_delay) as max_dep_delay,
   carrier
   FROM
   flights
   GROUP BY
   carrier
")

# We can compute the minimun, mean, and maximum values of a numeric value
ej4
#      mean_arr_delay    min_dep_delay   max_dep_delay   carrier
# 1       7.3796692           -24           747          9E
# 2       0.3642909           -24          1014          AA
# 3      -9.9308886           -21           225          AS
# 4       9.4579733           -43           502          B6
# 5       1.6443409           -33           960         DL
# 6      15.7964311           -32           548         EV
# 7      21.9207048           -27           853         F9
# 8      20.1159055           -22           602         FL
# 9      -6.9152047           -16          1301         HA
# 10     10.7747334           -26          1137         MQ
# 11     11.9310345           -14           154         OO
# 12      3.5580111           -20           483         UA
# 13      2.1295951           -19           500         US
# 14      1.7644644           -20           653         VX
# 15      9.6491199           -13           471         WN
# 16     15.5569853           -16           387         YV

### We could be also interested in knowing how many observations each carrier has
ej5 = sqldf("
   SELECT
   carrier, count(*) as count
   FROM
   flights
   GROUP BY
   carrier
")

ej5
#      carrier  count
# 1       9E    18460
# 2       AA   32729
# 3       AS   714
# 4       B6   54635
# 5       DL   48110
# 6       EV   54173
# 7       F9   685
# 8       FL   3260
# 9       HA   342
# 10      MQ   26397
# 11      OO   32
# 12      UA   58665
# 13      US   20536
# 14      VX   5162
# 15      WN   12275
# 16      YV   601

SQLの最も便利な機能は結合です。結合とは、1つの列を使用して両方のテーブルの値を一致させる1つのテーブルでテーブルAとテーブルBを結合することを意味します。実際には、さまざまな種類の結合がありますが、開始するにはこれらが最も有用なものになります。内部結合と左外部結合です。

# Let’s create two tables: A and B to demonstrate joins.
A = data.frame(c1 = 1:4, c2 = letters[1:4])
B = data.frame(c1 = c(2,4,5,6), c2 = letters[c(2:5)])

A
# c1 c2
# 1  a
# 2  b
# 3  c
# 4  d

B
# c1 c2
# 2  b
# 4  c
# 5  d
# 6  e

### INNER JOIN
# This means to match the observations of the column we would join the tables by.
inner = sqldf("
   SELECT
   A.c1, B.c2
   FROM
   A INNER JOIN B
   ON A.c1 = B.c1
")

# Only the rows that match c1 in both A and B are returned
inner
# c1 c2
#  2  b
#  4  c

### LEFT OUTER JOIN
# the left outer join, sometimes just called left join will return the
# first all the values of the column used from the A table
left = sqldf("
  SELECT
   A.c1, B.c2
  FROM
   A LEFT OUTER JOIN B
   ON A.c1 = B.c1
")

# Only the rows that match c1 in both A and B are returned
left
#   c1    c2
#    1  <NA>
#    2    b
#    3  <NA>
#    4    c

ビッグデータ分析-チャートとグラフ

データを分析する最初のアプローチは、視覚的に分析することです。これを行う目的は、通常、変数と変数の単変量記述との関係を見つけることです。私たちはこれらの戦略を次のように分けることができます-

単変量解析
多変量解析

一変量のグラフィカルな方法

単変量*は統計用語です。実際には、他のデータから独立して変数を分析することを意味します。これを効率的に行うことができるプロットは-

箱ひげ図

通常、ボックスプロットは分布を比較するために使用されます。分布に違いがあるかどうかを視覚的に検査するのに最適な方法です。カットごとにダイヤモンドの価格に違いがあるかどうかを確認できます。

# We will be using the ggplot2 library for plotting
library(ggplot2)
data("diamonds")

# We will be using the diamonds dataset to analyze distributions of numeric variables
head(diamonds)

#    carat   cut       color  clarity  depth  table   price    x     y     z
# 1  0.23    Ideal       E      SI2    61.5    55     326     3.95  3.98  2.43
# 2  0.21    Premium     E      SI1    59.8    61     326     3.89  3.84  2.31
# 3  0.23    Good        E      VS1    56.9    65     327     4.05  4.07  2.31
# 4  0.29    Premium     I      VS2    62.4    58     334     4.20  4.23  2.63
# 5  0.31    Good        J      SI2    63.3    58     335     4.34  4.35  2.75
# 6  0.24    Very Good   J      VVS2   62.8    57     336     3.94  3.96  2.48

### Box-Plots
p = ggplot(diamonds, aes(x = cut, y = price, fill = cut)) +
   geom_box-plot() +
   theme_bw()
print(p)

プロットでは、カットの種類ごとにダイヤモンドの価格の分布に違いがあることがわかります。

ボックスプロット

ヒストグラム

source('01_box_plots.R')

# We can plot histograms for each level of the cut factor variable using
facet_grid
p = ggplot(diamonds, aes(x = price, fill = cut)) +
   geom_histogram() +
   facet_grid(cut ~ .) +
   theme_bw()

p
# the previous plot doesn’t allow to visuallize correctly the data because of
the differences in scale
# we can turn this off using the scales argument of facet_grid

p = ggplot(diamonds, aes(x = price, fill = cut)) +
   geom_histogram() +
   facet_grid(cut ~ ., scales = 'free') +
   theme_bw()
p

png('02_histogram_diamonds_cut.png')
print(p)
dev.off()

上記のコードの出力は次のようになります-

ヒストグラム

多変量グラフィカルメソッド

探索的データ分析の多変量グラフィカルメソッドには、異なる変数間の関係を見つけるという目的があります。これを達成するために一般的に使用される2つの方法があります。数値変数の相関行列をプロットするか、生データを散布図の行列としてプロットするだけです。

これを実証するために、ダイヤモンドデータセットを使用します。コードに従うには、スクリプト bda/part2/charts/03_multivariate_analysis.R を開きます。

library(ggplot2)
data(diamonds)

# Correlation matrix plots
keep_vars = c('carat', 'depth', 'price', 'table')
df = diamonds[, keep_vars]
# compute the correlation matrix
M_cor = cor(df)

#          carat       depth      price      table
# carat 1.00000000  0.02822431  0.9215913  0.1816175
# depth 0.02822431  1.00000000 -0.0106474 -0.2957785
# price 0.92159130 -0.01064740  1.0000000  0.1271339
# table 0.18161755 -0.29577852  0.1271339  1.0000000

# plots
heat-map(M_cor)

コードは次の出力を生成します-

ヒートマップ

これは要約であり、価格とキャレットの間には強い相関関係があり、他の変数にはあまり関係がないことを示しています。

相関行列は、多数の変数がある場合に役立ちます。この場合、生データのプロットは実用的ではありません。前述のように、生データも表示することが可能です-

library(GGally)
ggpairs(df)

ヒートマップに表示される結果が確認されていることをプロットで確認できます。価格とカラット変数の間には0.922の相関があります。

ScatterPlot

この関係は、散布図行列の（3、1）インデックスにある価格-キャラット散布図で視覚化することができます。

ビッグデータ分析-データ分析ツール

データサイエンティストがデータを効果的に分析できるようにするさまざまなツールがあります。通常、データ分析のエンジニアリングの側面はデータベースに焦点を当てており、データ科学者はデータ製品を実装できるツールに焦点を当てています。次のセクションでは、さまざまなツールの利点について、データサイエンティストが実際に最も頻繁に使用する統計パッケージを中心に説明します。

Rプログラミング言語

Rは、統計分析に重点を置いたオープンソースのプログラミング言語です。 SAS、SPSSなどの商用ツールと統計機能の面で競争力があります。 C、C ++、Fortranなどの他のプログラミング言語へのインターフェースと考えられています。

Rのもう1つの利点は、利用可能な多数のオープンソースライブラリです。 CRANには無料でダウンロードできる6000以上のパッケージがあり、 Github にはさまざまなRパッケージがあります。

パフォーマンスの点では、使用可能なライブラリが大量にあるため、コードの遅いセクションがコンパイルされた言語で記述されているため、Rは集中的な操作に対して遅いです。ただし、深いforループの書き込みを必要とする操作を実行する場合は、Rが最適な選択肢ではありません。データ分析のために、 data.table、glmnet、ranger、xgboost、ggplot2、caret などの優れたライブラリがあり、高速プログラミング言語へのインターフェイスとしてRを使用できます。

データ分析用のPython

Pythonは汎用プログラミング言語であり、 pandas、scikit-learn、theano、numpy 、 scipy などのデータ分析専用のライブラリが多数含まれています。

Rで利用できる機能のほとんどはPythonでも実行できますが、Rの方が使いやすいことがわかりました。大規模なデータセットを使用している場合、通常はRよりもPythonの方が適しています。 Pythonを非常に効果的に使用して、データを1行ずつクリーンアップおよび処理できます。これはRからは可能ですが、スクリプトタスクのPythonほど効率的ではありません。

機械学習の場合、 scikit-learn は、中規模のデータセットを問題なく処理できる大量のアルゴリズムを利用できる優れた環境です。 Rの同等のライブラリ（キャレット）と比較して、 scikit-learn はよりクリーンで一貫性のあるAPIを備えています。

ジュリア

ジュリアは、テクニカルコンピューティング向けの高レベルで高性能な動的プログラミング言語です。その構文はRまたはPythonと非常に似ているため、すでにRまたはPythonを使用している場合は、同じコードをJuliaで書くのは非常に簡単です。この言語はかなり新しく、ここ数年で大幅に成長しているため、現時点では間違いなくオプションです。

ニューラルネットワークなどの計算集約的なプロトタイピングアルゴリズムには、ジュリアをお勧めします。それは研究のための素晴らしいツールです。実稼働環境でモデルを実装するという点では、おそらくPythonにはより優れた選択肢があります。ただし、R、Python、およびJuliaでモデルを実装するエンジニアリングを行うWebサービスがあるため、これは問題になりつつあります。

SAS

SASは、ビジネスインテリジェンスにまだ使用されている商用言語です。ユーザーが多種多様なアプリケーションをプログラムできるようにする基本言語を備えています。専門家ではないユーザーがプログラミングを必要とせずにニューラルネットワークライブラリなどの複雑なツールを使用できるようにする商用製品が多数含まれています。

商用ツールの明らかな欠点を超えて、SASは大規模なデータセットにうまく対応できません。中規模のデータセットでもSASに問題があり、サーバーがクラッシュします。小規模なデータセットを使用していて、ユーザーがデータ科学の専門家でない場合にのみ、SASをお勧めします。上級ユーザー向けに、RとPythonはより生産的な環境を提供します。

SPSS

SPSSは現在、統計分析用のIBMの製品です。主に調査データを分析するために使用され、プログラムできないユーザーにとっては、まともな代替手段です。 SASと同じくらい簡単に使用できますが、モデルの実装に関しては、モデルをスコアリングするSQLコードが提供されるため、より簡単です。通常、このコードは効率的ではありませんが、SASは各データベースのモデルを個別にスコアリングする製品を販売しているのに対し、開始点です。小さなデータと未経験のチームの場合、SPSSはSASと同様に優れたオプションです。

ただし、ソフトウェアはかなり制限されており、経験豊富なユーザーは、RまたはPythonを使用することで生産性が大幅に向上します。

Matlab、Octave

Matlabやそのオープンソースバージョン（Octave）など、他のツールも利用できます。これらのツールは主に研究に使用されます。機能に関しては、RまたはPythonはMatlabまたはOctaveで利用可能なすべてを実行できます。製品が提供するサポートに興味がある場合にのみ、製品のライセンスを購入するのが理にかなっています。

ビッグデータ分析-統計的手法

データを分析するとき、統計的アプローチをとることができます。基本的な分析を実行するために必要な基本的なツールは-

相関分析
分散分析
仮説検定

大規模なデータセットを使用する場合、これらの方法は相関分析を除いて計算集約的ではないため、問題はありません。この場合、サンプルを取得することは常に可能であり、結果は堅牢である必要があります。

相関分析

相関分析は、数値変数間の線形関係を見つけようとします。これはさまざまな状況で使用できます。一般的な用途の1つは、探索的データ分析です。本のセクション16.0.2には、このアプローチの基本的な例があります。まず、前述の例で使用される相関メトリックは、*ピアソン係数*に基づいています。ただし、異常値の影響を受けない相関の別の興味深いメトリックがあります。このメトリックは、スピアマン相関と呼ばれます。

スピアマン相関*メトリックは、ピアソン法よりも外れ値の存在に対してロバストであり、データが正規分布していない場合の数値変数間の線形関係の推定値を向上させます。

library(ggplot2)

# Select variables that are interesting to compare pearson and spearman
correlation methods.
x = diamonds[, c('x', 'y', 'z', 'price')]

# From the histograms we can expect differences in the correlations of both
metrics.
# In this case as the variables are clearly not normally distributed, the
spearman correlation

# is a better estimate of the linear relation among numeric variables.
par(mfrow = c(2,2))
colnm = names(x)
for(i in 1:4) {
   hist(x[[i]], col = 'deepskyblue3', main = sprintf('Histogram of %s', colnm[i]))
}
par(mfrow = c(1,1))

次の図のヒストグラムから、両方のメトリックの相関関係の違いを予測できます。この場合、変数は明らかに正規分布していないため、スピアマン相関は数値変数間の線形関係のより良い推定値です。

非正規分布

Rの相関を計算するには、このコードセクションがある bda/part2/statistical_methods/correlation/correlation.R ファイルを開きます。

## Correlation Matrix - Pearson and spearman
cor_pearson <- cor(x, method = 'pearson')
cor_spearman <- cor(x, method = 'spearman')

### Pearson Correlation
print(cor_pearson)
#            x          y          z        price
# x      1.0000000  0.9747015  0.9707718  0.8844352
# y      0.9747015  1.0000000  0.9520057  0.8654209
# z      0.9707718  0.9520057  1.0000000  0.8612494
# price  0.8844352  0.8654209  0.8612494  1.0000000

### Spearman Correlation
print(cor_spearman)
#              x          y          z      price
# x      1.0000000  0.9978949  0.9873553  0.9631961
# y      0.9978949  1.0000000  0.9870675  0.9627188
# z      0.9873553  0.9870675  1.0000000  0.9572323
# price  0.9631961  0.9627188  0.9572323  1.0000000

カイ二乗検定

カイ2乗検定では、2つの確率変数が独立しているかどうかをテストできます。これは、各変数の確率分布が他の変数に影響を与えないことを意味します。 Rでテストを評価するには、最初に分割表を作成し、次にテーブルを chisq.test R 関数に渡す必要があります。

たとえば、変数間に関連があるかどうかを確認しましょう：ダイヤモンドデータセットのカットと色。テストは次のように正式に定義されています-

H0：可変カットとダイヤモンドは独立しています
H1：可変カットとダイヤモンドは独立していません

名前によってこれら2つの変数間に関係があると仮定しますが、テストはこの結果がどれほど重要であるかを示す客観的な「ルール」を与えることができます。

次のコードスニペットでは、テストのp値が2.2e-16であることがわかりました。これは実際的にはほぼゼロです。次に、モンテカルロシミュレーション*を実行してテストを実行した後、p値は0.0004998であり、しきい値0.05よりもかなり低いことがわかりました。この結果は、帰無仮説（H0）を棄却することを意味するため、変数 *cut と color は独立していないと考えられます。

library(ggplot2)

# Use the table function to compute the contingency table
tbl = table(diamonds$cut, diamonds$color)
tbl

#              D    E    F    G    H    I    J
# Fair       163  224  312  314  303  175  119
# Good       662  933  909  871  702  522  307
# Very Good 1513 2400 2164 2299 1824 1204  678
# Premium   1603 2337 2331 2924 2360 1428  808
# Ideal     2834 3903 3826 4884 3115 2093  896

# In order to run the test we just use the chisq.test function.
chisq.test(tbl)

# Pearson’s Chi-squared test
# data:  tbl
# X-squared = 310.32, df = 24, p-value < 2.2e-16
# It is also possible to compute the p-values using a monte-carlo simulation
# It's needed to add the simulate.p.value = TRUE flag and the amount of
simulations
chisq.test(tbl, simulate.p.value = TRUE, B = 2000)

# Pearson’s Chi-squared test with simulated p-value (based on 2000 replicates)
# data:  tbl
# X-squared = 310.32, df = NA, p-value = 0.0004998

T検定

*t-test* の考え方は、名義変数の異なるグループ間で数値変数の分布に違いがあるかどうかを評価することです。 これを実証するために、因子変数カットの公正レベルと理想レベルのレベルを選択し、それら2つのグループ間で数値変数の値を比較します。

data = diamonds[diamonds$cut %in% c('Fair', 'Ideal'), ]

data$cut = droplevels.factor(data$cut) # Drop levels that aren’t used from the
cut variable
df1 = data[, c('cut', 'price')]

# We can see the price means are different for each group
tapply(df1$price, df1$cut, mean)
# Fair    Ideal
# 4358.758 3457.542

t検定は、 t.test 関数を使用してRに実装されています。 t.testへの式インターフェースは、それを使用する最も簡単な方法です。アイデアは、数値変数はグループ変数によって説明されるということです。

例：* t.test（numeric_variable〜group_variable、data = data）。前の例では、 *numeric_variable は price で、 group_variable は cut です。

統計的な観点から、数値変数の分布に2つのグループの違いがあるかどうかをテストしています。正式には、仮説検定は帰無仮説（H0）と対立仮説（H1）で記述されます。

H0：公正および理想グループ間で価格変数の分布に違いはありません
H1公正なグループと理想的なグループの間で価格変数の分布に違いがある

以下は、次のコードでRに実装することができます-

t.test(price ~ cut, data = data)

# Welch Two Sample t-test
#
# data:  price by cut
# t = 9.7484, df = 1894.8, p-value < 2.2e-16
# alternative hypothesis: true difference in means is not equal to 0
# 95 percent confidence interval:
#   719.9065 1082.5251
# sample estimates:
#   mean in group Fair mean in group Ideal
#   4358.758            3457.542

# Another way to validate the previous results is to just plot the
distributions using a box-plot
plot(price ~ cut, data = data, ylim = c(0,12000),
   col = 'deepskyblue3')

p値が0.05未満かどうかを確認することで、テスト結果を分析できます。この場合、対立仮説を維持します。これは、カットファクターの2つのレベル間で価格の違いが見つかったことを意味します。レベルの名前では、この結果を期待していましたが、Failグループの平均価格がIdealグループの平均価格よりも高いとは予想していませんでした。これは、各因子の平均を比較することで確認できます。

*plot* コマンドは、価格とカット変数の関係を示すグラフを作成します。 それは箱ひげ図です。このプロットはセクション16.0.1で説明しましたが、基本的には分析している2つのカットレベルの価格変数の分布を示しています。

異なるレベルカット

分散分析

分散分析（ANOVA）は、各グループの平均と分散を比較することにより、グループ分布間の差異を分析するために使用される統計モデルです。モデルはRonald Fisherによって開発されました。 ANOVAは、いくつかのグループの平均が等しいかどうかの統計的検定を提供するため、t検定を3つ以上のグループに一般化します。

ANOVAは、複数の2サンプルt検定を実行すると統計タイプIエラーが発生する可能性が高くなるため、3つ以上のグループの統計的有意性を比較するのに役立ちます。

数学的な説明を提供するという点で、テストを理解するには以下が必要です。

x〜ij〜= x （x〜i〜-x）（x〜ij〜-x）

これは、次のモデルにつながります-

x〜ij〜=μ+α〜i〜+ε〜ij〜

ここで、μは総平均、α〜i〜_はi番目のグループ平均です。エラー項∈〜ij〜_は、正規分布からiidであると仮定されます。テストの帰無仮説は次のとおりです-

α〜1〜=α〜2〜=…=α〜k〜

検定統計量の計算に関しては、2つの値を計算する必要があります-

グループ間の差の平方和-

SSD_B = \ sum _ \ {i} ^ \ {k} \ sum _ \ {j} ^ \ {n}（\ bar \ {x _ \ {\ bar \ {i}}}-\ bar \ {x}） ^ 2

*グループ内の平方和

SSD_W = \ sum _ \ {i} ^ \ {k} \ sum _ \ {j} ^ \ {n}（\ bar \ {x _ \ {\ bar \ {ij}}}-\ bar \ {x _ \ { \ bar \ {i}}}）^ 2

ここで、SSD〜B〜はk-1の自由度を持ち、SSD〜W〜はN-kの自由度を持ちます。次に、各メトリックの平均平方差を定義できます。

MS〜B〜= SSD〜B〜/（k-1）

MS〜w〜= SSD〜w〜/（N-k）

最後に、ANOVAの検定統計量は、上記の2つの量の比率として定義されます

F = MS〜B〜/MS〜w〜

_k-1_および_N-k_の自由度を持つF分布に従います。帰無仮説が真の場合、Fは1に近い可能性があります。そうでない場合、グループ間平均二乗MSBは大きくなる可能性が高く、その結果、F値が大きくなります。

基本的に、ANOVAは合計分散の2つのソースを調べ、どの部分がより寄与しているのかを確認します。グループ平均を比較することを目的としていますが、これが分散分析と呼ばれる理由です。

統計の計算に関しては、実際にはRで行うのはかなり簡単です。次の例は、その方法を示し、結果をプロットします。

library(ggplot2)
# We will be using the mtcars dataset

head(mtcars)
#                    mpg  cyl disp  hp drat  wt  qsec   vs am  gear carb
# Mazda RX4         21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
# Mazda RX4 Wag     21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
# Datsun 710        22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
# Hornet 4 Drive    21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
# Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
# Valiant           18.1   6  225 105 2.76 3.460 20.22  1  0    3    1

# Let's see if there are differences between the groups of cyl in the mpg variable.
data = mtcars[, c('mpg', 'cyl')]
fit = lm(mpg ~ cyl, data = mtcars)
anova(fit)

# Analysis of Variance Table
# Response: mpg
#           Df Sum Sq Mean Sq F value    Pr(>F)
# cyl        1 817.71  817.71  79.561 6.113e-10* * *
# Residuals 30 308.33   10.28
# Signif. codes:  0* * *0.001*  *0.01* 0.05 .
# Plot the distribution
plot(mpg ~ as.factor(cyl), data = mtcars, col = 'deepskyblue3')

コードは次の出力を生成します-

分散分析

この例で取得するp値は0.05より大幅に小さいため、Rはこれを示すために記号「*」を返します。これは、帰無仮説を棄却し、 cyl 変数の異なるグループ間でmpg平均の差を見つけることを意味します。

データ分析のための機械学習

機械学習は、パターン認識、コンピュータービジョン、音声認識、テキスト分析などのタスクを扱うコンピューターサイエンスのサブフィールドであり、統計や数学的最適化との強いつながりがあります。アプリケーションには、検索エンジンの開発、スパムフィルタリング、光学文字認識（OCR）などが含まれます。データマイニング、パターン認識、統計学習の分野の境界は明確ではなく、基本的にはすべて同様の問題に言及しています。

機械学習は、2種類のタスクに分けることができます-

教師あり学習
教師なし学習

教師あり学習

教師あり学習とは、行列_X_として定義された入力データがあり、応答_y_を予測することに関心があるタイプの問題を指します。ここで、_X = \ {x〜1〜、x〜2〜、…、x〜n〜} _には_n_予測子があり、2つの値_y = \ {c〜1〜、c〜2〜} _があります。

アプリケーションの例としては、人口統計学的特徴を予測子として使用して、Webユーザーが広告をクリックする確率を予測することが挙げられます。これは、クリック率（CTR）を予測するためによく呼び出されます。次に、_y = \ {クリック、しない-クリック} _し、予測子は、使用可能なIPアドレス、サイトに入った日、ユーザーの市、国などです。

教師なし学習

教師なし学習では、学習するクラスがなくても、互いに類似したグループを見つける問題を扱います。予測子からマッピングを学習し、各グループで類似したインスタンスを共有し、互いに異なるグループを見つけるタスクには、いくつかのアプローチがあります。

教師なし学習のアプリケーションの例は、顧客のセグメンテーションです。たとえば、電気通信業界の一般的なタスクは、ユーザーが電話に与える使用量に応じてユーザーをセグメント化することです。これにより、マーケティング部門は各グループを異なる製品でターゲットにできます。

ビッグデータ分析-Naive Bayes Classifier

単純ベイズは、分類器を構築するための確率的手法です。単純ベイズ分類器の特徴的な仮定は、特定の特徴の値が、クラス変数が与えられた他の特徴の値から独立していると考えることです。

前述の単純化された仮定にもかかわらず、単純なベイズ分類器は、複雑な実世界の状況で良い結果をもたらします。単純ベイズの利点は、分類に必要なパラメーターを推定するために少量のトレーニングデータのみが必要であり、分類器を段階的にトレーニングできることです。

Naive Bayesは条件付き確率モデルです：分類される問題インスタンスが与えられ、いくつかのn個の特徴（独立変数）を表すベクトル x =（x〜1〜、…、x〜n〜）で表され、これに割り当てられますKの可能な結果またはクラスごとのインスタンス確率。

p（C_k | x_1、.....、x_n）

上記の定式化の問題は、特徴の数nが大きい場合、または特徴が多数の値をとることができる場合、そのようなモデルを確率表に基づいて実行できないことです。したがって、モデルを再定式化してより単純にします。ベイズの定理を使用して、条件付き確率は次のように分解できます-

p（C_k | x）= \ frac \ {p（C_k）p（x | C_k）} \ {p（x）}

これは、上記の独立性の仮定の下では、クラス変数Cの条件付き分布が-

p（C_k | x_1、.....、x_n）\：= \：\ frac \ {1} \ {Z} p（C_k）\ prod _ \ {i = 1} ^ \ {n} p（ x_i | C_k）

ここで、証拠Z = p（ x ）はx〜1〜、…、x〜n〜のみに依存するスケーリング係数であり、特徴変数の値がわかっている場合は定数です。一般的なルールの1つは、最も可能性の高い仮説を選択することです。これは最大事後またはMAP決定ルールとして知られています。対応する分類器、ベイズ分類器は、次のようにいくつかのkにクラスラベル$ \ hat \ {y} = C_k $を割り当てる関数です-

\ hat \ {y} = argmax \：p（C_k）\ prod _ \ {i = 1} ^ \ {n} p（x_i | C_k）

Rでアルゴリズムを実装するのは簡単なプロセスです。次の例は、Naive Bayes分類器をトレーニングし、スパムフィルタリング問題の予測に使用する方法を示しています。

次のスクリプトは、 bda/part3/naive_bayes/naive_bayes.R ファイルで利用できます。

# Install these packages
pkgs = c("klaR", "caret", "ElemStatLearn")
install.packages(pkgs)
library('ElemStatLearn')
library("klaR")
library("caret")

# Split the data in training and testing
inx = sample(nrow(spam), round(nrow(spam) * 0.9))
train = spam[inx,]
test = spam[-inx,]

# Define a matrix with features, X_train
# And a vector with class labels, y_train
X_train = train[,-58]
y_train = train$spam
X_test = test[,-58]
y_test = test$spam
# Train the model
nb_model = train(X_train, y_train, method = 'nb',
   trControl = trainControl(method = 'cv', number = 3))

# Compute
preds = predict(nb_model$finalModel, X_test)$class
tbl = table(y_test, yhat = preds)
sum(diag(tbl))/sum(tbl)
# 0.7217391

結果からわかるように、Naive Bayesモデルの精度は72％です。これは、モデルがインスタンスの72％を正しく分類することを意味します。

ビッグデータ分析-K-Meansクラスタリング

k-meansクラスタリングは、n個の観測値をk個のクラスターに分割することを目的としています。各観測値は、クラスターのプロトタイプとして最も近い平均値を持つクラスターに属します。これにより、データ空間がボロノイセルに分割されます。

観測値のセット_（x〜1〜、x〜2〜、…、x〜n〜）_（各観測値はd次元の実ベクトル）が与えられると、k-meansクラスタリングは、n個の観測値をk個のグループに分割することを目的とします。 _G = \ {G〜1〜、G〜2〜、…、G〜k〜} _以下のように定義されたクラスター内平方和（WCSS）を最小化するために-

argmin \：\ sum _ \ {i = 1} ^ \ {k} \ sum _ \ {x \ in S _ \ {i}} \ parallel x-\ mu _ \ {i} \ parallel ^ 2

後の式は、k-meansクラスタリングで最適なプロトタイプを見つけるために最小化される目的関数を示しています。式の直観は、互いに異なるグループを見つけたいことであり、各グループの各メンバーは各クラスターの他のメンバーと類似している必要があります。

次の例は、Rでk-meansクラスタリングアルゴリズムを実行する方法を示しています。

library(ggplot2)
# Prepare Data
data = mtcars

# We need to scale the data to have zero mean and unit variance
data <- scale(data)

# Determine number of clusters
wss <- (nrow(data)-1)*sum(apply(data,2,var))
for (i in 2:dim(data)[2]) {
   wss[i] <- sum(kmeans(data, centers = i)$withinss)
}

# Plot the clusters
plot(1:dim(data)[2], wss, type = "b", xlab = "Number of Clusters",
   ylab = "Within groups sum of squares")

Kの適切な値を見つけるために、Kの異なる値に対してグループ内の平方和をプロットできます。このメトリックは通常、グループが追加されると減少します。グループ内の平方和の減少がゆっくりと減少し始めるポイントを見つけたいと思います。プロットでは、この値はK = 6で最適に表されます。

数値クラスター

Kの値が定義されたので、その値でアルゴリズムを実行する必要があります。

# K-Means Cluster Analysis
fit <- kmeans(data, 5) # 5 cluster solution

# get cluster means
aggregate(data,by = list(fit$cluster),FUN = mean)

# append cluster assignment
data <- data.frame(data, fit$cluster)

ビッグデータ分析-アソシエーションルール

_I = i〜1〜、i〜2〜、…、i〜n〜_を、アイテムと呼ばれるn個のバイナリ属性のセットとします。 _D = t〜1〜、t〜2〜、…、t〜m〜_をデータベースと呼ばれるトランザクションのセットとします。 Dの各トランザクションには一意のトランザクションIDがあり、Iのアイテムのサブセットが含まれています。ルールは、X⇒Yの形式の含意として定義されます。ここで、X、Y⊆IおよびX∩Y =∅です。

アイテムのセット（短いアイテムセットの場合）XおよびYは、ルールの前件（左側またはLHS）および後件（右側またはRHS）と呼ばれます。

概念を説明するために、スーパーマーケットドメインの小さな例を使用します。アイテムのセットはI = \ {ミルク、パン、バター、ビール}で、アイテムを含む小さなデータベースを次の表に示します。

Transaction ID	Items
1	milk, bread
2	bread, butter
3	beer
4	milk, bread, butter
5	bread, butter

スーパーマーケットのルールの例としては、\ {ミルク、パン}⇒\ {バター}が考えられます。これは、ミルクとパンを購入すると、顧客もバターを購入することを意味します。考えられるすべてのルールのセットから興味深いルールを選択するには、重要性と関心のさまざまな尺度の制約を使用できます。最もよく知られている制約は、サポートと信頼の最小しきい値です。

アイテムセットXのサポートsupp（X）は、アイテムセットを含むデータセット内のトランザクションの割合として定義されます。表1のサンプルデータベースでは、アイテムセット\ {milk、bread}は、すべてのトランザクションの40％（5トランザクション中2トランザクション）で発生するため、2/5 = 0.4をサポートしています。頻繁なアイテムセットを見つけることは、教師なし学習問題の単純化とみなすことができます。

ルールの信頼度は、conf（X⇒Y）= supp（X∪Y）/supp（X）で定義されます。たとえば、表1のデータベースでは、ルール\ {milk、bread}⇒\ {butter}の信頼度は0.2/0.4 = 0.5です。これは、ミルクとパンを含むトランザクションの50％でルールが正しいことを意味します。信頼度は、確率P（Y | X）の推定値として解釈できます。確率P（Y | X）は、これらのトランザクションにもLHSが含まれているという条件下で、トランザクションのルールのRHSを見つける確率です。

*bda/part3/apriori.R* にあるスクリプトには、* aprioriアルゴリズム*を実装するコードがあります。

# Load the library for doing association rules
# install.packages(’arules’)
library(arules)

# Data preprocessing
data("AdultUCI")
AdultUCI[1:2,]
AdultUCI[[fnlwgt"]] <- NULL
AdultUCI[[education-num"]] <- NULL

AdultUCI[[age"]] <- ordered(cut(AdultUCI[[ "age"]], c(15,25,45,65,100)),
   labels = c("Young", "Middle-aged", "Senior", "Old"))
AdultUCI[[hours-per-week"]] <- ordered(cut(AdultUCI[[ "hours-per-week"]],
   c(0,25,40,60,168)), labels = c("Part-time", "Full-time", "Over-time", "Workaholic"))
AdultUCI[[capital-gain"]] <- ordered(cut(AdultUCI[[ "capital-gain"]],
   c(-Inf,0,median(AdultUCI[[capital-gain"]][AdultUCI[[ "capitalgain"]]>0]),Inf)),
   labels = c("None", "Low", "High"))
AdultUCI[[capital-loss"]] <- ordered(cut(AdultUCI[[ "capital-loss"]],
   c(-Inf,0, median(AdultUCI[[capital-loss"]][AdultUCI[[ "capitalloss"]]>0]),Inf)),
   labels = c("none", "low", "high"))

aprioriアルゴリズムを使用してルールを生成するには、トランザクションマトリックスを作成する必要があります。次のコードは、Rでこれを行う方法を示しています。

# Convert the data into a transactions format
Adult <- as(AdultUCI, "transactions")
Adult
# transactions in sparse format with
# 48842 transactions (rows) and
# 115 items (columns)

summary(Adult)
# Plot frequent item-sets
itemFrequencyPlot(Adult, support = 0.1, cex.names = 0.8)

# generate rules
min_support = 0.01
confidence = 0.6
rules <- apriori(Adult, parameter = list(support = min_support, confidence = confidence))

rules
inspect(rules[100:110, ])
# lhs                             rhs                      support     confidence  lift
# {occupation = Farming-fishing} => {sex = Male}        0.02856148  0.9362416   1.4005486
# {occupation = Farming-fishing} => {race = White}      0.02831579  0.9281879   1.0855456
# {occupation = Farming-fishing} => {native-country     0.02671881  0.8758389   0.9759474
                                       = United-States}

ビッグデータ分析-デシジョンツリー

デシジョンツリーは、分類や回帰などの教師あり学習問題に使用されるアルゴリズムです。デシジョンツリーまたは分類ツリーは、各内部（非リーフ）ノードに入力フィーチャのラベルが付けられたツリーです。フィーチャでラベル付けされたノードからのアークは、フィーチャの可能な値のそれぞれでラベル付けされます。ツリーの各リーフには、クラスまたはクラス全体の確率分布のラベルが付けられます。

属性値テストに基づいてソースセットをサブセットに分割することにより、ツリーを「学習」できます。このプロセスは、*再帰的なパーティショニング*と呼ばれる再帰的な方法で、各派生サブセットで繰り返されます。ノードのサブセットのターゲット変数の値がすべて同じ場合、または分割によって予測に値が追加されなくなると、再帰が完了します。決定木のトップダウン誘導のこのプロセスは、貪欲なアルゴリズムの例であり、決定木を学習するための最も一般的な戦略です。

データマイニングで使用される決定木は、2つの主なタイプのものです-

分類ツリー-応答が名目上の変数である場合、たとえば電子メールがスパムであるかどうか。
回帰ツリー-予測された結果を実数とみなせる場合（例：労働者の給与）。

決定木は簡単な方法であり、そのためいくつかの問題があります。この問題の1つは、決定木が生成する結果モデルの分散が大きいことです。この問題を軽減するために、決定木のアンサンブル法が開発されました。現在広く使用されているアンサンブルメソッドの2つのグループがあります-

決定ツリーのバギング-これらのツリーを使用して、トレーニングデータを置換で繰り返しリサンプリングし、コンセンサス予測のためにツリーを投票することにより、複数の決定ツリーを構築します。このアルゴリズムは、ランダムフォレストと呼ばれています。
決定木をブースト-勾配ブーストは弱学習器を組み合わせます。この場合、意思決定ツリーを反復的な方法で単一の強力な学習者にします。弱いツリーをデータに適合させ、前のモデルのエラーを修正するために、弱学習器を繰り返し適合させます。

# Install the party package
# install.packages('party')
library(party)
library(ggplot2)

head(diamonds)
# We will predict the cut of diamonds using the features available in the
diamonds dataset.
ct = ctree(cut ~ ., data = diamonds)

# plot(ct, main="Conditional Inference Tree")
# Example output
# Response:  cut
# Inputs:  carat, color, clarity, depth, table, price, x, y, z

# Number of observations:  53940
#
# 1) table <= 57; criterion = 1, statistic = 10131.878
#   2) depth <= 63; criterion = 1, statistic = 8377.279
#     3) table <= 56.4; criterion = 1, statistic = 226.423
#       4) z <= 2.64; criterion = 1, statistic = 70.393
#         5) clarity <= VS1; criterion = 0.989, statistic = 10.48
#           6) color <= E; criterion = 0.997, statistic = 12.829
#             7)*  weights = 82
#           6) color > E

#Table of prediction errors
table(predict(ct), diamonds$cut)
#            Fair  Good Very Good Premium Ideal
# Fair       1388   171        17       0    14
# Good        102  2912       499      26    27
# Very Good    54   998      3334     249   355
# Premium      44   711      5054   11915  1167
# Ideal        22   114      3178    1601 19988
# Estimated class probabilities
probs = predict(ct, newdata = diamonds, type = "prob")
probs = do.call(rbind, probs)
head(probs)

ビッグデータ分析-ロジスティック回帰

ロジスティック回帰は、応答変数がカテゴリカルである分類モデルです。これは統計に基づくアルゴリズムであり、教師付き分類問題に使用されます。ロジスティック回帰では、コスト関数を最小化する次の方程式でパラメーターのベクトルβを見つけようとします。

logit（p_i）= ln \ left（\ frac \ {p_i} \ {1-p_i} \ right）= \ beta_0 + \ beta_1x _ \ {1、i} + ... + \ beta_kx _ \ {k、i}

次のコードは、ロジスティック回帰モデルをRに適合させる方法を示しています。ここでは、Naive Bayesで使用されたのと同じロジスティック回帰を示すために、スパムデータセットを使用します。

精度に関する予測結果から、Naive Bayes分類器で達成された72％と比較して、回帰モデルはテストセットで92.5％の精度を達成することがわかります。

library(ElemStatLearn)
head(spam)

# Split dataset in training and testing
inx = sample(nrow(spam), round(nrow(spam) *0.8))
train = spam[inx,]
test = spam[-inx,]

# Fit regression model
fit = glm(spam ~ ., data = train, family = binomial())
summary(fit)

# Call:
#   glm(formula = spam ~ ., family = binomial(), data = train)
#

# Deviance Residuals:
#   Min       1Q   Median       3Q      Max
# -4.5172  -0.2039   0.0000   0.1111   5.4944
# Coefficients:
# Estimate Std. Error z value Pr(>|z|)
# (Intercept) -1.511e+00  1.546e-01  -9.772  < 2e-16* * *
# A.1         -4.546e-01  2.560e-01  -1.776 0.075720 .
# A.2         -1.630e-01  7.731e-02  -2.108 0.035043*
# A.3          1.487e-01  1.261e-01   1.179 0.238591
# A.4          2.055e+00  1.467e+00   1.401 0.161153
# A.5          6.165e-01  1.191e-01   5.177 2.25e-07 ** *
# A.6          7.156e-01  2.768e-01   2.585 0.009747*  *
# A.7          2.606e+00  3.917e-01   6.652 2.88e-11* * *
# A.8          6.750e-01  2.284e-01   2.955 0.003127*  *
# A.9          1.197e+00  3.362e-01   3.559 0.000373* * *
# Signif. codes:  0* * *0.001*  *0.01* 0.05 . 0.1  1

### Make predictions
preds = predict(fit, test, type = ’response’)
preds = ifelse(preds > 0.5, 1, 0)
tbl = table(target = test$spam, preds)
tbl

#         preds
# target    0   1
# email   535  23
# spam     46 316
sum(diag(tbl))/sum(tbl)
# 0.925

ビッグデータ分析-時系列分析

時系列は、日付またはタイムスタンプでインデックス付けされたカテゴリ変数または数値変数の一連の観測です。時系列データの明確な例は、株価の時系列です。次の表では、時系列データの基本構造を見ることができます。この場合、観測は1時間ごとに記録されます。

Timestamp	Stock - Price
2015-10-11 09:00:00	100
2015-10-11 10:00:00	110
2015-10-11 11:00:00	105
2015-10-11 12:00:00	90
2015-10-11 13:00:00	120

通常、時系列分析の最初のステップは、シリーズをプロットすることです。これは通常、折れ線グラフで行われます。

時系列分析の最も一般的なアプリケーションは、データの時間構造を使用して数値の将来値を予測することです。つまり、利用可能な観測値を使用して、将来の値を予測します。

データの時間的順序は、従来の回帰方法が有用ではないことを意味します。堅牢な予測を構築するには、データの時間的順序を考慮したモデルが必要です。

時系列分析で最も広く使用されているモデルは、自己回帰移動平均（ARMA）と呼ばれます。このモデルは、自己回帰（AR）部分と*移動平均*（MA）部分の2つの部分で構成されています。通常、このモデルは_ARMA（p、q）_モデルと呼ばれます。ここで、_p_は自己回帰部分の次数、_q_は移動平均部分の次数です。

自己回帰モデル

_AR（p）_は、次数pの自己回帰モデルとして読み取られます。数学的には-

X_t = c + \ sum _ \ {i = 1} ^ \ {P} \ phi_i X _ \ {t-i} + \ varepsilon _ \ {t}

ここで、\ {φ〜1〜、…、φ〜p〜}は推定されるパラメーター、cは定数、ランダム変数ε〜t〜はホワイトノイズを表します。モデルが静止したままになるように、パラメーターの値にいくつかの制約が必要です。

移動平均

表記_MA（q）_は、次数_q_の移動平均モデルを指します-

X_t = \ mu + \ varepsilon_t + \ sum _ \ {i = 1} ^ \ {q} \ theta_i \ varepsilon _ \ {t-i}

ここで、θ〜1〜、…、θ〜q〜はモデルのパラメーター、μはX〜t〜の期待値、ε〜t〜、ε〜t − 1〜、… は、ホワイトノイズ誤差の項です。

自己回帰移動平均

_ARMA（p、q）_モデルは、p自己回帰項とq移動平均項を組み合わせます。数学的には、モデルは次の式で表されます-

X_t = c + \ varepsilon_t + \ sum _ \ {i = 1} ^ \ {P} \ phi_iX _ \ {t-1} + \ sum _ \ {i = 1} ^ \ {q} \ theta_i \ varepsilon _ \ { ti}

_ARMA（p、q）_モデルは_AR（p）_と_MA（q）_モデルの組み合わせであることがわかります。

モデルの直観を与えるために、X〜t〜の変数の値を予測するために、式のAR部分がX〜t-i〜観測のパラメーターを推定しようとすることを考慮してください。最終的には、過去の値の加重平均です。 MAセクションは同じアプローチを使用しますが、以前の観測の誤差ε〜t-i〜を使用します。したがって、最終的に、モデルの結果は加重平均になります。

次のコードスニペットは、R_で_ARMA（p、q）を実装する方法を示しています。

# install.packages("forecast")
library("forecast")

# Read the data
data = scan('fancy.dat')
ts_data <- ts(data, frequency = 12, start = c(1987,1))
ts_data
plot.ts(ts_data)

通常、データのプロットは、データに一時的な構造があるかどうかを確認する最初のステップです。プロットから、毎年の終わりに強いスパイクがあることがわかります。

時系列プロット

次のコードは、ARMAモデルをデータに適合させます。モデルのいくつかの組み合わせを実行し、エラーの少ないものを選択します。

# Fit the ARMA model
fit = auto.arima(ts_data)
summary(fit)

# Series: ts_data
# ARIMA(1,1,1)(0,1,1)[12]
#    Coefficients:
#    ar1     ma1    sma1
# 0.2401  -0.9013  0.7499
# s.e.  0.1427   0.0709  0.1790

#
# sigma^2 estimated as 15464184:  log likelihood = -693.69
# AIC = 1395.38   AICc = 1395.98   BIC = 1404.43

# Training set error measures:
#                 ME        RMSE      MAE        MPE        MAPE      MASE       ACF1
# Training set   328.301  3615.374  2171.002  -2.481166  15.97302  0.4905797 -0.02521172

ビッグデータ分析-テキスト分析

この章では、本のパート1でスクレイピングされたデータを使用します。データには、フリーランサーのプロファイルと、彼らがUSDで請求している時間料金を説明するテキストが含まれています。次のセクションのアイデアは、フリーランサーのスキルを考慮して、その時間給を予測できるモデルを適合させることです。

次のコードは、この場合はバッグオブワードマトリックスでユーザーのスキルを持つ生テキストを変換する方法を示しています。このために、tmと呼ばれるRライブラリを使用します。これは、コーパス内の各単語に対して、各変数の出現量を使用して変数を作成することを意味します。

library(tm)
library(data.table)

source('text_analytics/text_analytics_functions.R')
data = fread('text_analytics/data/profiles.txt')
rate = as.numeric(data$rate)
keep = !is.na(rate)
rate = rate[keep]

### Make bag of words of title and body
X_all = bag_words(data$user_skills[keep])
X_all = removeSparseTerms(X_all, 0.999)
X_all

# <<DocumentTermMatrix (documents: 389, terms: 1422)>>
#   Non-/sparse entries: 4057/549101
# Sparsity           : 99%
# Maximal term length: 80
# Weighting          : term frequency - inverse document frequency (normalized) (tf-idf)

### Make a sparse matrix with all the data
X_all <- as_sparseMatrix(X_all)

テキストがスパース行列として表されたので、スパースソリューションを提供するモデルに適合させることができます。この場合の適切な代替手段は、LASSO（最小絶対収縮および選択演算子）を使用することです。これは、最も関連性の高い機能を選択してターゲットを予測できる回帰モデルです。

train_inx = 1:200
X_train = X_all[train_inx, ]
y_train = rate[train_inx]
X_test = X_all[-train_inx, ]
y_test = rate[-train_inx]

# Train a regression model
library(glmnet)
fit <- cv.glmnet(x = X_train, y = y_train,
   family = 'gaussian', alpha = 1,
   nfolds = 3, type.measure = 'mae')
plot(fit)

# Make predictions
predictions = predict(fit, newx = X_test)
predictions = as.vector(predictions[,1])
head(predictions)

# 36.23598 36.43046 51.69786 26.06811 35.13185 37.66367
# We can compute the mean absolute error for the test data
mean(abs(y_test - predictions))
# 15.02175

これで、一連のスキルがフリーランサーの時間給を予測できるモデルができました。より多くのデータが収集されると、モデルのパフォーマンスは向上しますが、このパイプラインを実装するコードは同じになります。

ビッグデータ分析-オンライン学習

オンライン学習は、教師あり学習モデルを大規模なデータセットに拡張できる機械学習のサブフィールドです。基本的な考え方は、モデルに適合するためにメモリ内のすべてのデータを読み込む必要はなく、各インスタンスを一度に読み込むだけでよいということです。

この場合、ロジスティック回帰を使用してオンライン学習アルゴリズムを実装する方法を示します。ほとんどの教師あり学習アルゴリズムのように、最小化されたコスト関数があります。ロジスティック回帰では、コスト関数は次のように定義されます-

J（\ theta）\：= \：\ frac \ {-1} \ {m} \ left [\ sum _ \ {i = 1} ^ \ {m} y ^ \ {（i）} log（h_ \ {\ theta}（x ^ \ {（i）}））+（1-y ^ \ {（i）}）log（1-h _ \ {\ theta}（x ^ \ {（i）}）） \ right]

ここで、_J（θ）_はコスト関数を表し、_h〜θ〜（x）_は仮説を表します。ロジスティック回帰の場合、次の式で定義されます-

h_ \ theta（x）= \ frac \ {1} \ {1 + e ^ \ {\ theta ^ T x}}

コスト関数を定義したので、最小化するアルゴリズムを見つける必要があります。これを実現する最も簡単なアルゴリズムは、確率的勾配降下法と呼ばれます。ロジスティック回帰モデルの重みのアルゴリズムの更新ルールは次のように定義されています-

\ theta_j：= \ theta_j-\ alpha（h_ \ theta（x）-y）x

次のアルゴリズムにはいくつかの実装がありますが、https://github.com/JohnLangford/vowpal_wabbit/wiki [vowpal wabbit]ライブラリに実装されているものは、最も開発されたものです。このライブラリは、大規模な回帰モデルのトレーニングを可能にし、少量のRAMを使用します。クリエーター自身の言葉では、「Vowpal Wabbit（VW）プロジェクトは、Microsoft Researchおよび（以前は）Yahoo!がスポンサーとなっている高速なコア外学習システムです。研究"。

*kaggle* コンペティションのタイタニックデータセットを使用します。 元のデータは *bda/part3/vw* フォルダーにあります。 ここでは、2つのファイルがあります-

トレーニングデータ（train_titanic.csv）があり、
新しい予測を行うためのラベルなしデータ（test_titanic.csv）。

csv形式を vowpal wabbit 入力形式に変換するには、 csv_to_vowpal_wabbit.py Pythonスクリプトを使用します。このためには、当然pythonをインストールする必要があります。 bda/part3/vw フォルダーに移動し、ターミナルを開いて次のコマンドを実行します-

python csv_to_vowpal_wabbit.py

このセクションでは、Windowsを使用している場合、Unixコマンドラインをインストールする必要があるため、そのためのhttps://www.cygwin.com/[cygwin] Webサイトを入力してください。

端末を開き、フォルダ bda/part3/vw で次のコマンドを実行します-

vw train_titanic.vw -f model.vw --binary --passes 20 -c -q ff --sgd --l1
0.00000001 --l2 0.0000001 --learning_rate 0.5 --loss_function logistic

*vw call* の各引数の意味を分解してみましょう。

-f model.vw -後で予測を行うためにmodel.vwファイルにモデルを保存することを意味します
*-binary *--1、1ラベルのバイナリ分類として損失を報告
-20回通過-データは重みを学習するために20回使用されます
-c -キャッシュファイルを作成する
-q ff -f名前空間で2次機能を使用する
*-sgd *-定期的/古典的/単純な確率的勾配降下更新、つまり、非適応、非正規化、および不変量を使用します。
*-l1 --l2 *-L1およびL2ノルム正則化
*-learning_rate 0.5 *-更新ルールの式で定義された学習率α

次のコードは、コマンドラインで回帰モデルを実行した結果を示しています。結果では、平均のログ損失とアルゴリズムのパフォーマンスの小さなレポートを取得します。

-loss_function logistic
creating quadratic features for pairs: ff
using l1 regularization = 1e-08
using l2 regularization = 1e-07

final_regressor = model.vw
Num weight bits = 18
learning rate = 0.5
initial_t = 1
power_t = 0.5
decay_learning_rate = 1
using cache_file = train_titanic.vw.cache
ignoring text input in favor of cache input
num sources = 1

average    since         example   example  current  current  current
loss       last          counter   weight    label   predict  features
0.000000   0.000000          1      1.0    -1.0000   -1.0000       57
0.500000   1.000000          2      2.0     1.0000   -1.0000       57
0.250000   0.000000          4      4.0     1.0000    1.0000       57
0.375000   0.500000          8      8.0    -1.0000   -1.0000       73
0.625000   0.875000         16     16.0    -1.0000    1.0000       73
0.468750   0.312500         32     32.0    -1.0000   -1.0000       57
0.468750   0.468750         64     64.0    -1.0000    1.0000       43
0.375000   0.281250        128    128.0     1.0000   -1.0000       43
0.351562   0.328125        256    256.0     1.0000   -1.0000       43
0.359375   0.367188        512    512.0    -1.0000    1.0000       57
0.274336   0.274336       1024   1024.0    -1.0000   -1.0000       57 h
0.281938   0.289474       2048   2048.0    -1.0000   -1.0000       43 h
0.246696   0.211454       4096   4096.0    -1.0000   -1.0000       43 h
0.218922   0.191209       8192   8192.0     1.0000    1.0000       43 h

finished run
number of examples per pass = 802
passes used = 11
weighted example sum = 8822
weighted label sum = -2288
average loss = 0.179775 h
best constant = -0.530826
best constant’s loss = 0.659128
total feature number = 427878

これで、トレーニングした model.vw を使用して、新しいデータで予測を生成できます。

vw -d test_titanic.vw -t -i model.vw -p predictions.txt

前のコマンドで生成された予測は、[0、1]の範囲に収まるように正規化されていません。これを行うには、シグモイド変換を使用します。

# Read the predictions
preds = fread('vw/predictions.txt')

# Define the sigmoid function
sigmoid = function(x) {
   1/(1 + exp(-x))
}
probs = sigmoid(preds[[Generate class labels
preds = ifelse(probs > 0.5, 1, 0)
head(preds)
# [1] 0 1 0 0 1 0

Big-data-analytics-quick-guide

ビッグデータ分析-概要

ビッグデータ分析-データライフサイクル

従来のデータマイニングライフサイクル

CRISP-DM方法論

SEMMA方法論

ビッグデータのライフサイクル

ビジネス問題の定義

研究

人事評価

データ収集

データ変更

データストレージ

探索的データ分析

モデリングと評価のためのデータ準備

モデリング

実装

ビッグデータ分析-方法論

ビッグデータ分析-コア成果物

ビッグデータ分析-主要な利害関係者

ビッグデータ分析-データアナリスト

ビッグデータ分析-データサイエンティスト

ビッグデータ分析-問題定義

プロジェクトの説明

問題定義

教師付き分類

教師あり回帰

教師なし学習

ランク付けを学ぶ

ビッグデータ分析-データ収集

Twitter Miniプロジェクト

ビッグデータ分析-クレンジングデータ

Twitter Miniプロジェクト

ビッグデータ分析-データの要約

ビッグデータ分析-データ探索

ビッグデータ分析-データの可視化

ビッグデータ分析-Rの概要

ビッグデータ分析-SQLの概要

ビッグデータ分析-チャートとグラフ

一変量のグラフィカルな方法

箱ひげ図

ヒストグラム

多変量グラフィカルメソッド

ビッグデータ分析-データ分析ツール

Rプログラミング言語

データ分析用のPython

ジュリア

SAS

SPSS

Matlab、Octave

ビッグデータ分析-統計的手法

相関分析

カイ二乗検定

T検定

分散分析

データ分析のための機械学習

教師あり学習

教師なし学習

ビッグデータ分析-Naive Bayes Classifier

ビッグデータ分析-K-Meansクラスタリング

ビッグデータ分析-アソシエーションルール

ビッグデータ分析-デシジョンツリー

ビッグデータ分析-ロジスティック回帰

ビッグデータ分析-時系列分析

自己回帰モデル

移動平均

自己回帰移動平均

ビッグデータ分析-テキスト分析

ビッグデータ分析-オンライン学習