Oracle® R Enterprise

ユーザーズ・ガイド

リリース1.4

E52975-01(原本部品番号:E39886-01)

2014年2月

Oracle R Enterpriseユーザーズ・ガイド リリース1.4

E52975-01

Copyright © 2012, 2014, Oracle and/or its affiliates.All rights reserved.

原本主著者: David McDermid

原本協力者: Margaret Taft

協力者: Patrick Aboyoun、Dmitry Golovashkin、Mark Hornick、Sherry Lamonica、Kathy Taylor、Qin Wang、Lei Zhang

このソフトウェアおよび関連ドキュメントの使用と開示は、ライセンス契約の制約条件に従うものとし、知的財産に関する法律により保護されています。ライセンス契約で明示的に許諾されている場合もしくは法律によって認められている場合を除き、形式、手段に関係なく、いかなる部分も使用、複写、複製、翻訳、放送、修正、ライセンス供与、送信、配布、発表、実行、公開または表示することはできません。このソフトウェアのリバース・エンジニアリング、逆アセンブル、逆コンパイルは互換性のために法律によって規定されている場合を除き、禁止されています。

ここに記載された情報は予告なしに変更される場合があります。また、誤りが無いことの保証はいたしかねます。誤りを見つけた場合は、オラクル社までご連絡ください。

このソフトウェアまたは関連ドキュメントが、米国政府機関もしくは米国政府機関に代わってこのソフトウェアまたは関連ドキュメントをライセンスされた者に提供される場合は、次のNoticeが適用されます。

U.S. GOVERNMENT END USERS: Oracle programs, including any operating system, integrated software, any programs installed on the hardware, and/or documentation, delivered to U.S. Government end users are "commercial computer software" pursuant to the applicable Federal Acquisition Regulation and agency-specific supplemental regulations. As such, use, duplication, disclosure, modification, and adaptation of the programs, including any operating system, integrated software, any programs installed on the hardware, and/or documentation, shall be subject to license terms and license restrictions applicable to the programs. No other rights are granted to the U.S. Government.

このソフトウェアまたはハードウェアは様々な情報管理アプリケーションでの一般的な使用のために開発されたものです。このソフトウェアまたはハードウェアは、危険が伴うアプリケーション(人的傷害を発生させる可能性があるアプリケーションを含む)への用途を目的として開発されていません。このソフトウェアまたはハードウェアを危険が伴うアプリケーションで使用する際、このソフトウェアまたはハードウェアを安全に使用するために、適切な安全装置、バックアップ、冗長性(redundancy)、その他の対策を講じることは使用者の責任となります。このソフトウェアまたはハードウェアを危険が伴うアプリケーションで使用したことに起因して損害が発生しても、オラクル社およびその関連会社は一切の責任を負いかねます。

OracleおよびJavaはOracle およびその関連企業の登録商標です。その他の名称は、それぞれの所有者の商標または登録商標です。

Intel、Intel Xeonは、Intel Corporationの商標または登録商標です。すべてのSPARCの商標はライセンスをもとに使用し、SPARC International, Inc.の商標または登録商標です。AMD、Opteron、AMDロゴ、AMD Opteronロゴは、Advanced Micro Devices, Inc.の商標または登録商標です。UNIXはThe Open Groupの登録商標です。

このソフトウェアまたはハードウェアおよびドキュメントは、第三者のコンテンツ、製品、サービスへのアクセス、あるいはそれらに関する情報を提供することがあります。オラクル社およびその関連会社は、第三者のコンテンツ、製品、サービスに関して一切の責任を負わず、いかなる保証もいたしません。オラクル社およびその関連会社は、第三者のコンテンツ、製品、サービスへのアクセスまたは使用によって損失、費用、あるいは損害が発生しても、一切の責任を負いかねます。

目次

例一覧

タイトルおよび著作権情報

はじめに

- 対象読者

- ドキュメントのアクセシビリティについて

- 関連ドキュメント

- Oracle R Enterpriseのオンライン・リソース

- 表記規則

Oracle R Enterpriseのこのリリースでの変更内容

- Oracle R Enterprise 1.4での変更内容

- Oracle R Enterprise 1.3での変更内容

- Oracle R Enterprise 1.1での変更内容

1 Oracle R Enterpriseの概要

- Oracle R Enterpriseについて

- Oracle R Enterpriseの利点

- Oracle R Enterpriseのクラス、関数およびメソッドのオンライン・ヘルプの取得

- Oracle DatabaseのデータでのRの透過的な使用について

- 透過層について

- Rのデータ型およびクラスの透過層サポート

- Oracle R Enterpriseのデータ型およびクラスについて

- ore.frameクラスについて

- Rのネーミング規則のサポート

- RおよびOracle R Enterpriseのクラス・タイプの強制変換について

- Oracle R Enterprise使用時の通常の操作

- Oracle R Enterpriseのグローバル・オプション

- Oracle R Enterpriseの例

- Oracle R Enterpriseの例のリスト

- Oracle R Enterpriseのサンプル・スクリプトの実行

2 Oracle R Enterpriseの概要

- Oracle Databaseインスタンスへの接続

- データベースへの接続について

- ore.connect関数の使用について

- ore.disconnect関数の使用について

- ore.connect関数およびore.disconnect関数の使用方法

- Oracle DatabaseでのRオブジェクトの作成および管理

- データベース内データ用のRオブジェクトの作成

- データベース・オブジェクト用Rオブジェクトの作成について

- ore.sync関数の使用方法

- ore.get関数の使用方法

- ore.attach関数の使用方法

- 順序付けられたおよび順序付けられていないore.frameオブジェクトの作成

- ore.frameオブジェクトの順序付けについて

- 順序付けに関連するグローバル・オプション

- キーを使用した順序付け

- 行名を使用した順序付け

- 順序付けられたフレームの使用方法

- データベースに対するデータの移動

- データベース表の作成および削除

- データベースでのRオブジェクトの保存および管理

- Oracle R Enterpriseオブジェクトの永続について

- Oracle R Enterpriseのデータストアについて

- データストアへのオブジェクトの保存

- データストアのコンテンツに関する情報の取得

- データストアからのオブジェクトのリストア

- データストアの削除

- 埋込みRの実行でのデータストアの使用について

3 データベースでのデータの準備および探索

- Oracle R Enterpriseを使用したデータベースのデータの準備

- データベースでのデータの準備について

- データの選択

- データの索引付け

- データの結合

- データの集計

- データの変換

- データのサンプリング

- データのパーティショニング

- 時系列データの準備

- データの探索

- 探索的データ分析関数について

- サンプルのNARROWデータセットについて

- データの相互関連付け

- データのクロス集計

- クロス集計の頻度の分析

- 時系列データでの指数平滑法モデルの構築

- データのランキング

- データのソート

- データの集計

- 数値変数の分布の分析

- クライアントでのサード・パーティのパッケージの使用方法

4 Oracle R Enterpriseでのモデルの構築

- Oracle R Enterpriseモデルの構築

- OREmodels関数について

- サンプルのlongleyデータセットについて

- 線形回帰モデルの構築

- 一般化線形モデルの構築

- ニューラル・ネットワーク・モデルの構築

- Oracle Data Miningモデルの構築

- Oracle R Enterpriseを使用したOracle Data Miningモデルの構築について

- Oracle R EnterpriseでサポートされるOracle Data Miningモデル

- Oracle R Enterpriseの関数で構築されるOracle Data Miningモデルについて

- 相関ルール・モデルの構築

- 属性評価モデルの構築

- ディシジョン・ツリー・モデルの構築

- 一般化線形モデルの構築

- k-Meansモデルの構築

- Naive Bayesモデルの構築

- Non-Negative Matrix Factorizationモデルの構築

- 直交パーティショニング・クラスタ・モデルの構築

- サポート・ベクター・マシン・モデルの構築

5 Rモデルでの予測

6 Oracle R Enterpriseの埋込みRの実行の使用方法

- Oracle R Enterpriseの埋込みRの実行について

- 埋込みRの実行の利点

- 埋込みRの実行用のAPI

- スクリプトのセキュリティに関する考慮事項

- パラレル実行のサポート

- 埋込みRの実行で使用するためのサード・パーティのパッケージのインストール

- 埋込みRの実行用のRインタフェース

- スクリプトを実行する関数の引数

- 実行するための入力関数

- オプションの引数

- 戻り値の構造

- 入力データ

- パラレル実行

- 固有の引数

- 埋込みRスクリプトでの自動データベース接続

- ore.doEval関数の使用方法

- ore.tableApply関数の使用方法

- ore.groupApply関数の使用方法

- 単一列のパーティショニング

- 複数列のパーティショニング

- ore.rowApply関数の使用方法

- ore.indexApply関数の使用方法

- ore.indexApply関数の簡単な使用例

- 列並行の使用例

- シミュレーションの使用例

- ore.scriptCreate関数およびore.scriptDrop関数の使用方法

- 埋込みRの実行用のSQLインタフェース

- SQLスクリプトの登録および管理

- Oracle R EnterpriseのSQL関数について

- rqGroupEval関数の使用方法

- データストアでのSQL関数およびオブジェクトの使用方法

- SQLでのデータストア管理

A Oracle R EnterpriseでサポートされるR演算子およびR関数

索引

例一覧

- 1-1 Oracle R Enterpriseのクラス、関数およびメソッドに関するヘルプの取得

- 1-2 Oracle R Enterpriseのドキュメントの表示

- 1-3 Rでの種ごとの花弁の長さの平均の調査

- 1-4 例1-3に相当するSQL

- 1-5 data.frameおよび対応するore.frameのクラス

- 1-6 RおよびOracle R Enterpriseのクラス・タイプの強制変換

- 1-7 Oracle R Enterpriseの例をリストするためのデモの使用方法

- 1-8 basic.Rサンプル・スクリプトの実行

- 2-1 ore.connectの使用方法およびSIDの指定

- 2-2 ore.connectの使用方法およびサービス名の指定

- 2-3 ore.connectの使用方法および簡単な接続文字列の指定

- 2-4 ore.connectの使用方法および完全な接続文字列の指定

- 2-5 ore.connectの使用方法および空の接続文字列の指定

- 2-6 ore.frameプロキシ・オブジェクトをR環境に追加するためのore.syncの使用方法

- 2-7 データベース表を取得するためのore.getの使用方法

- 2-8 データベース・スキーマの環境を追加するためのore.attachの使用方法

- 2-9 キーを使用した順序付け

- 2-10 行名を使用した順序付け

- 2-11 順序付けられたおよび順序付けられていないore.frameオブジェクトのマージ

- 2-12 データを移動するためのore.pushおよびore.pullの使用方法

- 2-13 表を作成および削除するためのore.createおよびore.dropの使用方法

- 2-14 オブジェクトの保存およびデータストアの作成

- 2-15 ore.datastore関数の使用方法

- 2-16 ore.datastoreSummary関数の使用方法

- 2-17 データストアからオブジェクトをリストアするためのore.load関数の使用方法

- 2-18 ore.delete関数の使用方法

- 3-1 列によるデータの選択

- 3-2 行によるデータの選択

- 3-3 値によるデータの選択

- 3-4 ore.frameオブジェクトの索引付け

- 3-5 2つの表のデータの結合

- 3-6 データの集計

- 3-7 データのフォーマット

- 3-8 transform関数の使用方法

- 3-9 派生列の追加

- 3-10 簡単なランダム・サンプリング

- 3-11 分割データ・サンプリング

- 3-12 系統的サンプリング

- 3-13 層別サンプリング

- 3-14 クラスタ・サンプリング

- 3-15 割当てサンプリング

- 3-16 データのランダムなパーティショニング

- 3-17 日時データの集計

- 3-18 日付および時間の計算の使用方法

- 3-19 日付および時間の比較

- 3-20 日付および時間のアクセッサの使用方法

- 3-21 日付および時間のデータ型の強制変換

- 3-22 ウィンドウ関数の使用方法

- 3-23 NARROWデータ・セット

- 3-24 基本的な相関計算の実行

- 3-25 相関マトリクスの作成

- 3-26 単一列頻度表の作成

- 3-27 2つの列の分析

- 3-28 行の重み付け

- 3-29 クロス集計データの順序付け

- 3-30 3つ以上の列の分析

- 3-31 列の範囲の指定

- 3-32 別の列の値ごとに1つのクロス集計表の作成

- 3-33 2つの列の値のセットごとに1つのクロス集計表の作成

- 3-34 階層化によるクロス集計の拡張

- 3-35 ビニングおよびその後のクロス集計

- 3-36 ore.freq関数の使用方法

- 3-37 二重指数平滑法モデルの構築

- 3-38 トランザクション・データを使用した時系列モデルの構築

- 3-39 間隔を指定した二重指数平滑法モデルの構築

- 3-40 2つの列のランキング

- 3-41 ランキングでの同順位の処理

- 3-42 グループ内のランキング

- 3-43 十分位数へのパーティショニング

- 3-44 累積分布関数の見積り

- 3-45 ランクのスコアリング

- 3-46 降順での列のソート

- 3-47 列ごとに異なる順序でのソート

- 3-48 ソートおよび一意の値ごとに1行を返す

- 3-49 重複列の削除

- 3-50 重複列の削除および一意の値ごとに1列を返す

- 3-51 出力での相対順序の維持

- 3-52 2つの列の異なる順序でのソート

- 3-53 2つの列の異なる順序でのソートおよび一意の組合せの生成

- 3-54 デフォルトの統計の計算

- 3-55 歪度およびt-検定の可能性の計算

- 3-56 重み付け合計の計算

- 3-57 2つの列によるグループ化

- 3-58 すべての適用可能な方法でのグループ化

- 3-59 デフォルトの単変量統計の計算

- 3-60 デフォルトの単変量統計の計算

- 3-61 完全な分位統計の計算

- 3-62 クライアントへのサード・パーティのパッケージのロード

- 4-1 longleyデータセットの値の表示

- 4-2 ore.lmの使用方法

- 4-3 ore.stepwise関数の使用方法

- 4-4 ore.glm関数の使用方法

- 4-5 ニューラル・ネットワーク・モデルの構築

- 4-6 ore.neuralの使用方法および活性化の指定

- 4-7 ore.odmAssocRules関数の使用方法

- 4-8 ore.odmAI関数の使用方法

- 4-9 ore.odmDT関数の使用方法

- 4-10 線形回帰モデルの構築

- 4-11 ore.odmGLMモデルの係数に対するリッジ推定の使用方法

- 4-12 ロジスティック回帰GLMの構築

- 4-13 ロジスティック回帰GLMの構築での参照値の指定

- 4-14 ore.odmKM関数の使用方法

- 4-15 ore.odmNB関数の使用方法

- 4-16 ore.odmNMF関数の使用方法

- 4-17 ore.odmOC関数の使用方法

- 4-18 ore.odmSVM関数の使用方法および混同マトリクスの生成

- 4-19 ore.odmSVM関数の使用方法および回帰モデルの構築

- 4-20 ore.odmSVM関数の使用方法および異常検出モデルの構築

- 5-1 LMモデルでのore.predict関数の使用方法

- 5-2 GLMモデルでのore.predict関数の使用方法

- 6-1 単一のデータベースへのパッケージのインストール

- 6-2 DCLIを使用したパッケージのインストール

- 6-3 ore.doEval関数の使用方法

- 6-4 オプションの引数を指定したore.doEval関数の使用方法

- 6-5 FUN.NAME引数を指定したore.doEval関数の使用方法

- 6-6 FUN.VALUE引数を指定したore.doEval関数の使用方法

- 6-7 ore.connect引数を指定したdoEval関数の使用方法

- 6-8 ore.tableApply関数の使用方法

- 6-9 ore.groupApply関数の使用方法

- 6-10 複数列でデータをパーティションする場合のore.groupApplyの使用方法

- 6-11 ore.rowApply関数の使用方法

- 6-12 ore.indexApply関数の使用方法

- 6-13 ore.indexApply関数の使用方法および結果の結合

- 6-14 シミュレーションでのore.indexApply関数の使用方法

- 6-15 ore.scriptCreate関数およびore.scriptDrop関数の使用方法

- 6-16 Rスクリプトの登録および使用方法

- 6-17 rqTableEvalの使用方法およびデータストアの指定

はじめに

このマニュアルでは、Oracle R Enterpriseの使用方法について説明します。

対象読者

このドキュメントは、Oracle R Enterpriseの全ユーザーを対象としています。Oracle R Enterpriseを使用するには、RとOracle Databaseの知識が必要です。

ドキュメントのアクセシビリティについて

オラクル社のアクセシビリティへの取組みの詳細は、Oracle Accessibility ProgramのWebサイトhttp://www.oracle.com/pls/topic/lookup?ctx=acc&id=docaccを参照してください。

Oracleサポートへのアクセス

Oracleのお客様は、My Oracle Supportにアクセスして電子サポートを受けることができます。詳細は、http://www.oracle.com/pls/topic/lookup?ctx=acc&id=infoまたはhttp://www.oracle.com/pls/topic/lookup?ctx=acc&id=trs (聴覚障害者向け)を参照してください。

関連ドキュメント

次の各ドキュメントは、Oracle Advanced Analyticsオプションに関連しています。

- 『Oracle R Enterpriseインストレーションおよび管理ガイド』

- 『Oracle R Enterpriseリリース・ノート』

- 『Oracle Data Mining概要』

- 『Oracle Data Miningユーザーズ・ガイド』

Oracle R Enterpriseのオンライン・リソース

次のWebサイトに、Oracle R Enterpriseのユーザーにとって役立つ情報を提供しています。

- Oracle Technology Network (OTN)のOracle R Enterpriseページでは、ダウンロード、最新のドキュメントおよびホワイト・ペーパー、ブログ、ディスカッション・フォーラム、プレゼンテーション、チュートリアルなどの情報を提供しています。Webサイトはhttp://www.oracle.com/technetwork/database/options/advanced-analytics/r-enterprise/index.htmlにあります。

- Oracle R Enterpriseのディスカッション・フォーラム(https://forums.oracle.com/forums/forum.jspa?forumID=1397)では、Oracle R Enterprise、Oracle R Connector for Hadoop (Big Data Connectorsの一部)、Oracle R DistributionなどのOracleのR関連の製品のすべての側面についてサポートしています。このフォーラムを利用して、このソフトウェアに関する質問やコメントを投稿してください。

- Oracle R Enterpriseのブログ(https://blogs.oracle.com/R/)では、従来の環境とBig Data環境の両方にOracle R EnterpriseおよびOracle R Connector for Hadoopを適用するためのベスト・プラクティス、ヒントおよびコツについて意見を交わします。

- Rの詳細は、http://www.r-project.orgの「R Project for Statistical Computing」を参照してください。

表記規則

このマニュアルでは次の表記規則を使用します。

規則

意味

太字

太字は、操作に関連するGraphical User Interface要素、または本文中で定義されている用語および用語集に記載されている用語を示します。

イタリック体

イタリックは、ユーザーが特定の値を指定するプレースホルダ変数を示します。

固定幅フォント

固定幅フォントは、段落内のコマンド、URL、サンプル内のコード、画面に表示されるテキスト、または入力するテキストを示します。

Oracle R Enterpriseのこのリリースでの変更内容

Oracle R Enterpriseの各リリースには、多くの場合、新しい機能が含まれています。次の各トピックでは、現在のリリースおよび以前の一部のリリースの機能について説明します。

- Oracle R Enterprise 1.4での変更内容

- Oracle R Enterprise 1.3での変更内容

- Oracle R Enterprise 1.1での変更内容

Oracle R Enterprise 1.4での変更内容

次のトピックでは、Oracle R Enterprise 1.4での変更内容について説明します。

- Oracle R Enterprise 1.4での新機能

Oracle R Enterprise 1.4での新機能

Oracle R Enterprise 1.4での変更内容は次のとおりです。

- データ・プレゼンテーション関数で追加および改善された点は次のとおりです。

- 新しいfactanal関数は、数値列を含むformulaオブジェクトまたはore.frameオブジェクトでファクタ分析を実行します。

- princomp関数のどちらの署名も、scores、subsetおよびna.actionの引数をサポートします。

- 新しいgetXlevels関数は、ore.frameオブジェクトに関連するmodel.matrixコールのxlev引数で使用可能なファクタ・レベルのリストを作成します。

- 新しい探索的データ分析関数であるore.esmは、時系列データの指数平滑法モデルを構築します。この関数は、単純指数平滑法または二重指数平滑法のいずれかを使用してモデルを構築します。この関数は、集計や欠損値の処理などの操作を使用して時系列データを事前処理できます。「時系列データでの指数平滑法モデルの構築」を参照してください。

- Oracle R Enterpriseの回帰関数およびニューラル・ネットワーク・モデル関数で追加および改善された点は次のとおりです。

- 新しいore.glm関数は、ロジスティック回帰、プロビット回帰およびポアソン回帰を含む、一般化線形モデルを適合するための方法を提供します。「一般化線形モデルの構築」を参照してください。

- ore.lm関数およびore.stepwise関数でモデル式で列を導出する際の、1,000列までの制限がなくなりました。

- ore.lm関数は、加重最小二乗回帰を実行するためのweights引数をサポートするようになりました。

- anova関数は、ore.lmオブジェクトの分散分析を実行できるようになりました。

- ore.stepwise関数では、direction引数の値が変更されました。値bothでは、追加より削除が優先されるようになりました。新しいdirection引数の値alternateは、以前のboth値の意味を持ちます。

- ore.neural関数にいくつかの新しい引数が追加されました。

- Oracle Data Miningモデルのアルゴリズム関数で追加および改善された点は次のとおりです。

- 新しいore.odmAssocRules関数は、Aprioriアルゴリズムを使用してOracle Data Miningの相関モデルを構築します。「相関ルール・モデルの構築」を参照してください。

- 新しいore.odmNMF関数は、特徴抽出にNon-Negative Matrix Factorization(NMF)アルゴリズムを使用してOracle Data Miningモデルを構築します。「Non-Negative Matrix Factorizationモデルの構築」を参照してください。

- 新しいore.odmOC関数は、クラスタ化に直交パーティショニング・クラスタ(O-Cluster)アルゴリズムを使用してOracle Data Miningモデルを構築します。「直交パーティショニング・クラスタ・モデルの構築」を参照してください。

- Oracle R Enterpriseの追加のグローバル・オプションであるore.parallel。「Oracle R Enterpriseのグローバル・オプション」を参照してください。

Oracle R Enterprise 1.3での変更内容

次の各トピックでは、Oracle R Enterprise 1.3での変更内容について説明します。

- Oracle R Enterprise 1.3での新機能

- Oracle R Enterprise 1.3でのその他の変更内容

Oracle R Enterprise 1.3での新機能

Oracle R Enterprise 1.3での新機能は次のとおりです。

- OREpredictパッケージでのデータベース内データを使用するRモデルでの予測

- row.names<-を使用した順序付けおよび索引付け

- OREodmパッケージを使用したOracle Data Miningモデルでの予測

- データベースでのRオブジェクトの保存および管理

- 日時データ型

- サンプリングおよびパーティショニング

- 列の詳細名

- 埋込みRスクリプトでのOracle Databaseインスタンスへの自動接続

- ore.neural関数を使用したデータベース内データを使用するRニューラル・ネットワークの構築

Oracle R Enterprise 1.3でのその他の変更内容

このリリースでのその他の変更は次のとおりです。

- インストールおよび管理情報は、このマニュアルから『Oracle R Enterpriseインストレーションおよび管理ガイド』に移動しました。インストールおよび管理に関連する新機能は、そちらのマニュアルを参照してください。

Oracle R Enterprise 1.1での変更内容

Oracle R Enterprise 1.1での新機能は次のとおりです。

- 追加のオペレーティング・システムのサポート

- Oracle R DistributionおよびOracle R Enterpriseは、IBM AIX 5.3以上および64-bit SPARCおよび64-bit x386(Intel)の両方のプロセッサの10以上でサポートされるようになりました。

- Oracle R Enterpriseサーバーは、64-bitおよび32-bitのWindowsオペレーティング・システムで稼働するようになりました。

- Rの数学ライブラリの向上

- Oracle R EnterpriseでIntel Math Kernel Library (MKL)とAMD Core Math Library (ACML)のいずれかを動的に選択するためのサポートによって向上したOracle R Distributionを使用できるようになりました。

- Solarisでは、BLASおよびLAPACKの高速な操作のために、Oracle R DistributionがOracle SUNパフォーマンス・ライブラリと動的にリンクされます。

- Oracle Walletのサポートでは、Rスクリプトでクリア・テキストのデータベース認証資格証明を使用する必要がなくなりました。そのために、Oracle R EnterpriseがOracleウォレットと統合されています。

- 改善されたインストール・スクリプトでは、より多くの前提条件チェックおよび詳細なエラー・メッセージが提供されます。エラー・メッセージが、解決するためのアクションに関する具体的な説明を提供します。

1 Oracle R Enterpriseの概要

この章ではOracle R Enterpriseの概要を説明します。この章の内容は次のとおりです。

- Oracle R Enterpriseについて

- Oracle R Enterpriseの利点

- Oracle R Enterpriseのクラス、関数およびメソッドのオンライン・ヘルプの取得

- Oracle DatabaseのデータでのRの透過的な使用について

- Oracle R Enterprise使用時の通常の操作

- Oracle R Enterpriseのグローバル・オプション

- Oracle R Enterpriseの例

関連項目:
『Oracle R Enterpriseインストレーションおよび管理ガイド』

Oracle R Enterpriseについて

Oracle R Enterpriseは、Oracle Database Enterprise EditionのOracle Advanced Analyticsオプションのコンポーネントの1つです。Oracle R Enterpriseは、本番環境への迅速なデプロイが可能な、Rでのエンドツーエンド分析プロセス用の包括的なデータベース集中型の環境です。これは、RパッケージおよびOracle Database機能のセットで、Rユーザーは、SQLを使用せずにデータベース常駐データを操作でき、そのデータベース・サーバーで稼働する1つ以上の埋込みRエンジンでRスクリプトを実行できます。

Oracle R EnterpriseをローカルのRセッションから使用すると、Oracle Databaseインスタンスのデータに簡単にアクセスできます。データベース表のデータを指定するRオブジェクトを作成および使用できます。Oracle R Enterpriseには、R操作をデータベース内で実行するSQLに変換するオーバーロードされた関数があります。データベースはSQLを統合し、SQL文の実行時に、問合せの最適化、パラレル処理およびデータベースのスケーラビリティ機能を使用できます。データベースは結果をRオブジェクトとして返します。

埋込みRの実行は、Oracle R Enterpriseの使用による最も重要な利点のいくつかを提供します。埋込みRの実行を使用すると、RインタフェースまたはSQLインタフェース、あるいは両方を介してデータベース内のRスクリプトを格納および実行できます。Rスクリプトの結果を、構造化データ、Rオブジェクトおよびイメージに対するSQL対応のツールで使用できます。

関連項目:
「Oracle R Enterpriseの利点」

Oracle R Enterpriseの利点

Oracle R Enterpriseを使用したOracle Databaseインスタンスのデータの準備および分析では、Rユーザーにとって多くの利点があります。Oracle R Enterpriseを使用して、次のことを実行できます。

- SQLを使用せずにデータベース常駐データを操作。Oracle R Enterpriseには、標準のR構文をSQLに透過的に変換するオーバーロードされたオープン・ソースRのメソッドおよび関数があります。これらのメソッドおよび関数は、Oracle R Enterpriseの透過層を実装するパッケージに含まれています。これらの関数およびメソッドを使用することで、データベースに常駐するデータに対するアクセス、分析および操作を行うRオブジェクトを作成できます。データベースは、SQLを自動的に最適化して問合せの効率を向上できます。

- データの移動を排除。データベースにデータを保持することによって、デスクトップ・コンピュータへのデータの転送にかかる時間およびデータをローカルに格納する必要性をなくします。また、ローカルに格納したデータの管理(データ・ファイルの適切な場所への配布、本番データベースで行われた変更とのデータの同期などのタスクが含まれます)を必要なくします。

- データをセキュアに保持。データをデータベースに保持することによって、データ管理用のOracle Databaseのセキュリティ、スケーラビリティ、信頼性およびバックアップの各機能を利用できます。

- データベースの能力を使用。データベース常駐データを直接操作することによって、データベースのメモリーおよび処理能力を使用でき、クライアントのRセッションのメモリーの制約を回避できます。

- 最新のデータを使用。データはデータベースでリフレッシュされるため、最新のデータにただちにアクセスできます。

- データベースでデータを準備。透過層関数を使用して、順序付け、集計、フィルタ処理、記録などの操作を介した予測分析用、およびSQLコードを記述することなく総括的サンプリング手法を使用するための、大規模なデータベース常駐データ・セットを準備します。

- データベースにRオブジェクトを保存。Rオブジェクトを他の場所から使用可能な永続データベース・オブジェクトとしてOracle Databaseインスタンスに保存できます。RオブジェクトおよびOracle R EnterpriseオブジェクトをOracle Databaseが管理するOracle R Enterpriseのデータストアに格納できます。

- データベースにモデルを構築。データベースにモデルを構築して、Oracle R Enterpriseのデータストアにそれらを格納および管理できます。CRAN (Comprehensive R Archive Network)からダウンロードするパッケージにある関数を使用して、大量のメモリーを必要とし、アンサンブル・モデリングなどの手法を使用するモデルを構築できます。

- データベースのデータをスコアリング。 スクリプトにRモデルを含めてデータベース常駐データをスコアリングできます。次のようなタスクを実行できます。

- スコアリングに同じRコードを使用できるため、モデル構築からスコアリングに1つの手順で移動します。一部のスタンドアロン分析サーバーで必要なスコアリング・ロジックの変換は必要ありません。

- バルク・スコアリングなどのタスクを実行するためにスクリプトが自動的に実行されるようにスケジュールします。

- トランザクションのコンテキストでデータをスコアリングします。

- オンラインのwhat-ifスコアリングを実行します。

- オプションでモデルをSQLに変換しますが、これはOracle Databaseによって自動的に実行されます。その後、生成されたSQLを低遅延スコアリング・タスクにデプロイできます。

- データベースでRスクリプトを実行。Oracle R Enterpriseの埋込みRの実行機能を使用して、データベースでRスクリプトを作成、格納および実行できます。このスクリプトの実行時に、Oracle Databaseは、データベース・サーバーでパラレルに実行可能な1つ以上のRエンジンを開始、制御および管理します。データベース・サーバーでスクリプトを実行することによって、サーバーのスケーラビリティおよびパフォーマンスを活用できます。
埋込みRの実行機能を使用すると、次のことを実行できます。

- Rスクリプトを対話式に開発およびテストし、SQLアプリケーションでスクリプトを使用できるようにします。

- データベース・サーバー上のRスクリプトでCRANおよび他のパッケージを使用します。

- Rスクリプト全体を本番アプリケーションで操作できるようにし、Rコードの移植を排除することで、Rの結果を既存のアプリケーションに統合するためのコードの作り直しを回避します。

- Oracle DatabaseをRスクリプトの高パフォーマンス・コンピューティング(HPC)環境としてシームレスに使用することで、データのパラレル化およびリソース管理を提供します。

- Oracle Databaseの処理リソースおよびメモリー・リソース、およびデータベースと埋込みRの実行のRエンジン間の読取り/書込み操作の高い効率性を使用します。

- データ・パラレル操作およびタスク・パラレル操作でのデータベースのパラレル処理機能を使用します。

- パラレル・シミュレーションを実行します。

- RアプリケーションまたはSQLアプリケーションで使用可能なXMLイメージおよびPNGイメージを生成します。

- Oracleテクノロジ・スタックと統合。Oracleテクノロジ・スタックのあらゆる側面を利用して、ビジネス・インテリジェンスや科学調査といった、より大規模なフレームワーク内に、独自のデータ分析を統合できます。たとえば、Oracle R Enterpriseの分析結果をOracle Business Intelligence Enterprise Edition (OBIEE)に統合できます。

Oracle R Enterpriseのクラス、関数およびメソッドのオンライン・ヘルプの取得

Oracle R Enterpriseのクライアント・パッケージには、Oracle Databaseのデータとの相互作用に使用するRコンポーネントが含まれています。クライアント・パッケージのリストおよび簡単な説明については、『Oracle R Enterpriseインストレーションおよび管理ガイド』を参照してください。

Oracle R Enterpriseのクラス、関数およびメソッドに関するヘルプを取得するには、help、showMethodsなどのR関数を使用します。クラスまたは関数の名前にore接頭辞が付いている場合は、help関数にその名前を指定できます。オープン・ソースR関数のオーバーロードされたメソッドに関するヘルプを取得するには、メソッドの名前およびoreクラスの名前を指定します。

例1-1には、Oracle R Enterpriseのクラス、関数およびメソッドに関する情報の取得のためのいくつかの例を示します。例の後にあるリストでは、一部のコードは結果の一部のみを表示するために変更されていて、一部の関数の出力は表示されていません。

例1-1 Oracle R Enterpriseのクラス、関数およびメソッドに関するヘルプの取得

# List the contents of the OREbase package.
ls("package:OREbase")

# Get help for the OREbase package.
help("OREbase")

# Get help for the ore virtual class.
help("ore-class")

# Show the subclasses of the ore virtual class.
showClass("ore")

# Get help on the ore.vector class.
help("ore.vector")

# Show the arguments for the aggregate method.
showMethods("aggregate")

# Get help on the aggregate method for an ore.vector object.
help("aggregate,ore.vector-method")

# Get help on the ore.frame class.
help(ore.frame)

# Show the signatures for the merge method.
showMethods("merge")

# Get help on the merge method for an ore.frame object.
help("merge,ore.frame,ore.frame-method")

showMethods("scale")

# Get help on the scale method for an ore.number object.
help("scale,ore.number-method")

# Get help on the ore.connect function.
help("ore.connect")

例1-1のリスト

R> options(width = 80)
# List the contents of the OREbase package.
R> head(ls("package:OREbase"), 12)
[1] "%in%"          "Arith"         "Compare"       "I"
[5] "Logic"         "Math"          "NCOL"          "NROW"
[9] "Summary"       "as.data.frame" "as.env"        "as.factor"
R>
R># Get help for the OREbase package.
R> help("OREbase")      # Output not shown.
R>
R> # Get help for the ore virtual class.
R> help("ore-class")    # Output not shown.
R>
R># Show the subclasses of the ore virtual class.
R> showClass("ore")
Virtual Class "ore" [package "OREbase"]

No Slots, prototype of class "ore.vector"

Known Subclasses:
Class "ore.vector", directly
Class "ore.frame", directly
Class "ore.matrix", directly
Class "ore.number", by class "ore.vector", distance 2
Class "ore.character", by class "ore.vector", distance 2
Class "ore.factor", by class "ore.vector", distance 2
Class "ore.date", by class "ore.vector", distance 2
Class "ore.datetime", by class "ore.vector", distance 2
Class "ore.difftime", by class "ore.vector", distance 2
Class "ore.logical", by class "ore.vector", distance 3
Class "ore.integer", by class "ore.vector", distance 3
Class "ore.numeric", by class "ore.vector", distance 3
Class "ore.tblmatrix", by class "ore.matrix", distance 2
Class "ore.vecmatrix", by class "ore.matrix", distance 2
R>
R># Get help on the ore.vector class.
R> help("ore.vector")    # Output not shown.
R>
R># Show the arguments for the aggregate method.
R> showMethods("aggregate")
Function: aggregate (package stats)
x="ANY"
x="ore.vector"

# Get help on the aggregate method for an ore.vector object.
R> help("aggregate,ore.vector-method")      # Output not shown.

# Get help on the ore.frame class.
R> help(ore.frame)       # Output not shown.

# Show the signatures for the merge method.
R> showMethods("merge")
Function: merge (package base)
x="ANY", y="ANY"
x="data.frame", y="ore.frame"
x="ore.frame", y="data.frame"
x="ore.frame", y="ore.frame

# Get help on the merge method for an ore.frame object.
R> help("merge,ore.frame,ore.frame-method")  # Output not shown.

R> showMethods("scale")
Function: scale (package base)
x="ANY"
x="ore.frame"
x="ore.number"
x="ore.tblmatrix"
x="ore.vecmatrix"

# Get help on the scale method for an ore.number object.
R> help("scale,ore.number-method")    # Output not shown.

# Get help on the ore.connect function.
R> help("ore.connect")                # Output not shown.

例1-2に示すとおり、RセッションでOREShowDoc関数を呼び出すことで、Oracle R EnterpriseのドキュメントをHTML形式またはPDF形式で表示できます。この関数は、このリリースのOracleドキュメント・ライブラリを表示するブラウザを起動します。

例1-2 Oracle R Enterpriseのドキュメントの表示

OREShowDoc()

関連項目:

- Oracle R Enterpriseのクライアント・パッケージのインストールの詳細は、『Oracle R Enterpriseインストレーションおよび管理ガイド』を参照してください。

Oracle DatabaseのデータでのRの透過的な使用について

Oracle R Enterpriseには、Oracle Databaseインスタンスのデータを直接操作するために使用できるオーバーロードされたオープン・ソースRメソッドがあります。このメソッドおよび関数は、R関数をSQLに変換する透過層を実装するパッケージに含まれています。

Oracle R Enterpriseの透過層パッケージおよびRをSQLに変換する際の制限について、次の各項で説明します。

- 「透過層について」

- Rのデータ型およびクラスの透過層サポート

関連項目:
第2章「Oracle R Enterpriseの概要」

透過層について

Oracle R Enterpriseの透過層は、OREbase、OREgraphicsおよびOREstatsのパッケージで実装されます。これらのOracle R Enterpriseパッケージには、オープン・ソースRのbase、graphicsおよびstatsのパッケージに関数のオーバーロードされたメソッドがそれぞれ含まれています。また、Oracle R Enterpriseパッケージには、一部のオープン・ソースR関数のOracle R Enterprise版も含まれています。

これらのパッケージのメソッドおよび関数を使用することで、Oracle Databaseインスタンスのデータを指定するRオブジェクトを作成できます。そのようなオブジェクトを使用するR式を実行すると、メソッドおよび関数はSQL問合せを透過的に生成してデータベースに送信します。その後、データベースはその問合せを実行して、操作の結果をRオブジェクトとして返します。

データベース表またはビューは、data.frameのサブクラスであるore.frameオブジェクトで表されます。その他のOracle R Enterpriseクラスは、ore.vector、vectorなどの対応するRクラスから継承されます。Oracle R Enterpriseは、Oracle Databaseのデータ型をOracle R Enterpriseのクラスに(NUMBERをore.integerに)マップします。Oracle R Enterpriseのデータ型およびオブジェクト・マッピングの詳細は、「Rのデータ型およびクラスの透過層サポート」を参照してください。

例1-3に、R関数呼出しのSQLへの変換を示します。これは、オーバーロードされたOracle R Enterpriseのaggregate関数を使用して、例1-3のIRIS_TABLEオブジェクトから花弁の長さの平均を取得します。

例1-3 Rでの種ごとの花弁の長さの平均の調査

aggplen = aggregate(IRIS_TABLE$Petal.Length,
by = list(species = IRIS_TABLE$Species),
FUN = mean)
aggplen

例1-3のリスト

R> aggplen = aggregate(IRIS_TABLE$Petal.Length,
by = list(species = IRIS_TABLE$Species),
FUN = mean)
R> aggplen
species     x
setosa         setosa 1.462
versicolor versicolor 4.260
virginica   virginica 5.552

例1-4に、例1-3のaggregate関数に相当するSQLを示します。

例1-4 例1-3に相当するSQL

SELECT "Species", AVG("Petal.Length")
FROM IRIS_TABLE
GROUP BY "Species"
ORDER BY "Species";

Species     AVG("PETAL.LENGTH")
----------- -------------------
setosa       1.4620000000000002
versicolor   4.26
virginica    5.552

透過層メソッドおよび関数を使用して、分析用のデータベース常駐データを準備できます。次に、他のOracle R Enterpriseパッケージの関数を使用して、モデルを構築および適合し、それを使用してデータをスコアリングできます。大規模なデータセットでは、Oracle Databaseに埋め込まれたRエンジンを使用してモデリングおよびスコアリングを実行できます。

関連項目:

- R、Oracle R EnterpriseおよびSQLのデータ型およびオブジェクトの対応の詳細は、「Rのデータ型およびクラスの透過層サポート」を参照してください。

- 第2章「Oracle R Enterpriseの概要」

Rのデータ型およびクラスの透過層サポート

Oracle R Enterpriseの透過層には、Rデータ型をOracle Databaseデータ型にマップするクラスおよびデータ型があります。これらのクラスおよびデータ型について、次の各項で説明します。

- Oracle R Enterpriseのデータ型およびクラスについて

- ore.frameクラスについて

- Rのネーミング規則のサポート

- RおよびOracle R Enterpriseのクラス・タイプの強制変換について

Oracle R Enterpriseのデータ型およびクラスについて

Oracle R Enterpriseには、Rデータ型をSQLデータ型にマップするデータ型があります。Rセッションでは、Rオブジェクトからデータベース・オブジェクトを作成するか、データベース・データからRオブジェクトを作成すると、Oracle R EnterpriseはRデータ型をSQLデータ型に変換し、可能な場合はその逆を実行します。データ型マッピングのリストは、表1-1を参照してください。

Oracle R Enterpriseは、Oracle R Enterpriseのクラスのインスタンスであるオブジェクトを作成します。Oracle R Enterpriseは、多くの標準のR関数をオーバーロードし、それらでOracle R Enterpriseのクラスおよびデータ型を使用できるようにします。

R言語の構造および構文は、Oracle Databaseオブジェクトにマップされているオブジェクトでサポートされます。Oracle R EnterpriseでサポートされるR演算子および関数の詳細は、付録Aを参照してください。

表1-1に、R、Oracle R EnterpriseおよびSQLのデータ型のマッピングをリストします。

表1-1 R、Oracle R EnterpriseおよびSQLのデータ型のマッピング

Rデータ型

Oracle R Enterpriseデータ型

SQLデータ型

キャラクタ・モードのvector

ore.character

VARCHAR2

INTERVALYEARTOMONTH

整数モードのvector

ore.integer

NUMBER

論理モードのvector

ore.logical

NUMBERはFALSEの場合は0、TRUEの場合は1

数値モードのvector

ore.number

BINARY_DOUBLE

BINARY_FLOAT

FLOAT

NUMBER

Date

ore.date

DATE

POSIXct

POSIXlt

ore.datetime

TIMESTAMP

TIMESTAMPWITHTIMEZONE

TIMESTAMPWITHLOCALTIMEZONE

difftime

ore.difftime

INTERVALDAYTOSECOND

サポート対象外

LONG

LONG RAW

RAW

ユーザー定義のデータ型

参照データ型

注意:
タイプore.datetimeのオブジェクトはタイム・ゾーン設定をサポートしていないため、かわりに、システム・タイム・ゾーンSys.timezoneが使用可能な場合はそれを使用し、Sys.timezoneを使用できない場合はGMTを使用します。

ore.frameクラスについて

ore.frameオブジェクトは、Oracle Databaseインスタンスに対するリレーショナル問合せを表します。これはdata.frameに相当するOracle R Enterpriseのオブジェクトです。通常は、データベース表のプロキシであるore.frameオブジェクトを取得します。次に、ore.frameプロキシ・オブジェクトに新しい列を追加するか、他の変更を行います。そのような変更は、基礎となる表には影響しません。その後でore.frameオブジェクトのソース表からデータをリクエストした場合は、透過層関数が選択リストに追加の列があるSQL問合せを生成しますが、その表は変更されません。

Rでは、data.frameの要素に明示的な順序付けがあります。整数索引付けを使用して要素を指定できます。一方、リレーショナル・データベース表では行の順序が定義されないため、Rデータ構造に直接マップできません。

表に主キー(行内で個別のタプルを形成する1つ以上の列のセット)がある場合は、SELECT文でORDER BY句を使用することで順序付けられた結果を生成できます。ただし、リレーショナル・データの順序付けは負荷が高く、多くの場合、透過層操作では不要です。たとえば、ore.frameでsummary関数を呼び出す場合、サマリー統計の計算に順序付けは必要ありません。

Oracle R Enterpriseには、ore.frameオブジェクトの順序付けられたものと順序付けられていないものの両方があります。これらのオブジェクトの作成および使用の詳細は、「序付けられたおよび順序付けられていないore.frameオブジェクトの作成」を参照してください。

例1-5では、様々なデータ型を含む列があるdata.frameを作成し、data.frameの構造を表示します。この例では次に、ore.push関数を呼び出して、data.frameのデータのコピーを含むデータベースに一時表を作成します。ore.pushの呼出しでは、その表のプロキシであるore.frameオブジェクトも生成されます。この例では、ore.frameオブジェクトとdata.frameオブジェクトおよびore.frameオブジェクトにある列のクラスを表示します。

例1-5 data.frameおよび対応するore.frameのクラス

df <- data.frame(a="abc",
b=1.456,
c=TRUE,
d=as.integer(1),
e=Sys.Date(),
f=as.difftime(c("0:3:20", "11:23:15")))
ore.push(df)
class(of)
class(df$a
class(of$a)
class(df$b)
class(of$b)
class(df$c)
class(of$c)
class(df$d)
class(of$d)
class(df$e)
class(of$e)
class(df$f)
class(of$f)

例1-5のリスト

R> df <- data.frame(a="abc",
+                   b=1.456,
+                   c=TRUE,
+                   d=as.integer(1),
+                   e=Sys.Date(),
+                   f=as.difftime(c("0:3:20", "11:23:15")))
R> ore.push(df)
R> class(of)
[1] "ore.frame"
attr(,"package")
[1] "OREbase"
R> class(df$a)
[1] "factor"
R> class(of$a)
[1] "ore.factor"
attr(,"package")
[1] "OREbase"
R> class(df$b)
[1] "numeric"
R> class(of$b)
[1] "ore.numeric"
attr(,"package")
[1] "OREbase"
R> class(df$c)
[1] "logical"
R> class(of$c)
[1] "ore.logical"
attr(,"package")
[1] "OREbase"
R> class(df$d)
[1] "integer"
R> class(of$d)
[1] "ore.integer"
attr(,"package")
[1] "OREbase"
R> class(df$e)
[1] "Date"
R> class(of$e)
[1] "ore.date"
attr(,"package")
[1] "OREbase"
R> class(df$f)
[1] "difftime"
R> class(of$f)
[1] "ore.difftime"
attr(,"package")
[1] "OREbase"

関連項目:
ore.createの詳細は、「データベースに対するデータの移動」を参照してください。

Rのネーミング規則のサポート

Oracle R Enterpriseは、ore.frame列に対して、より制限的なOracle Databaseのネーミング規則ではなくRのネーミング規則を使用します。ore.frameの列には、30バイトより長く、二重引用符を含む、一意でない名前を付けることができます。

RおよびOracle R Enterpriseのクラス・タイプの強制変換について

汎用のas.ore関数は、メモリー内Rオブジェクトをoreオブジェクトに強制変換します。より厳密なas.ore.characterなどの関数は、オブジェクトを特定の型に強制変換します。ore.push関数は、Rクラス・タイプをoreクラス・タイプに暗黙的に強制変換し、ore.pull関数は、oreクラス・タイプをRクラス・タイプに強制変換します。これらの関数の詳細は、「データベースに対するデータの移動」を参照してください。

例1-6に、Rオブジェクトのoreオブジェクトへの強制変換を示し、Rのintegerオブジェクトを作成してから汎用メソッドas.oreを使用してore.integerであるoreオブジェクトに強制変換します。この例では、Rオブジェクトを他の様々なoreクラス・タイプに強制変換します。埋込みRの実行関数でのas.factorの使用例は、例6-9「ore.groupApply関数の使用方法」を参照してください。

例1-6 RおよびOracle R Enterpriseのクラス・タイプの強制変換

x <- 1:10
class(x)
X <- as.ore(x)
class(X)
Xn <- as.ore.numeric(x)
class(Xn)
Xc <- as.ore.character(x)
class(Xc)
Xc
Xf <- as.ore.factor(x)
Xf

例1-6のリスト

R> x <- 1:10
R> class(x)
[1] "integer"
R> X <- as.ore(x)
R> class(X)
[1] "ore.integer"
attr(,"package")
[1] "OREbase"
R> Xn <- as.ore.numeric(x)
R> class(Xn)
[1] "ore.numeric"
attr(,"package")
[1] "OREbase"
R> Xc <- as.ore.character(x)
R> class(Xc)
[1] "ore.character"
attr(,"package")
[1] "OREbase"
R> Xc
[1] "1"  "2"  "3"  "4"  "5"  "6"  "7"  "8"  "9"  "10"
R> Xf <- as.ore.factor(x)
R> Xf
[1] 1  2  3  4  5  6  7  8  9  10
Levels: 1 10 2 3 4 5 6 7 8 9

Oracle R Enterprise使用時の通常の操作

Oracle R Enterpriseの使用での一般的な操作の進め方を次に示します。

1. Rセッションで、Oracle Databaseインスタンスのスキーマに接続します。

2. スキーマをアタッチして、データベース表に対するOracle R Enterpriseのプロキシ・オブジェクトを生成するスキーマ・オブジェクトと同期化します。

3. 分析用のデータを準備し、探索的データ分析およびデータの視覚化を実行する場合があります。

4. OREmodelsパッケージまたはOREdmパッケージの関数を使用してモデルを構築します。

5. ローカルのRセッションで、または埋込みRの実行を使用して、モデルを使用してデータをスコアリングします。

6. 分析結果をエンド・ユーザーにデプロイします。

図1-1に、これらの手順および手順の一般的な繰返しを示します。

図1-1 一般的なOracle R Enterpriseのワークフロー

第2章「Oracle R Enterpriseの概要」では、次の操作について説明します。

- データベースへの接続。

- データベース表に対するOracle R Enterpriseプロキシ・オブジェクトの作成。

- ローカルのRセッションのdata.frameからデータベース表(ore.frameプロキシ・オブジェクトと表される)へのデータの移動、およびその逆。

第3章「データベースでのデータの準備および探索」では、分析用のデータの準備およびデータの探索について説明します。データの準備および探索には、次のような操作が含まれる可能性があります。

- データセットまたは表からのデータの選択。

- 不要な情報をフィルタ処理することによるデータのクリーニング。

- データの順序付け。

- データの中間集計。

- 時系列分析。

- データの記録または書式設定。

- 探索的データ分析。

第4章「Oracle R Enterpriseでのモデルの構築」では、OREmodelsパッケージおよびOREdmパッケージの関数を使用して、Oracle Data Miningモデルを含むモデルの構築について説明します。

第5章「Rモデルでの予測」では、Oracle R Enterpriseモデルでのore.predict関数の使用について説明します。

第6章「Oracle R Enterpriseの埋込みRの実行の使用方法」では、データベースで稼働中の1つ以上のRエンジンでRスクリプトを作成および実行する方法、およびそれらのスクリプトのOracle Databaseのスクリプト・リポジトリへの保存方法について説明します。

Oracle R Enterpriseのグローバル・オプション

Oracle R Enterpriseには、様々な関数に適用されるグローバル・オプションがあります。表1-2に、Oracle R Enterpriseのグローバル・オプションおよび説明をリストします。

表1-2 Oracle R Enterpriseのグローバル・オプション

グローバル

説明

ore.na.extract

ore.frameオブジェクトまたはore.vectorオブジェクトの論理サブスクリプト中に使用される論理値。TRUEが指定されると、NA論理サブスクリプトを含む行または要素は、NA値を含む行または要素を生成しますが、これは、Rによるdata.frame値およびvector値の欠損値の論理サブスクリプトの処理方法を模倣します。

FALSEが指定されると、NA論理サブスクリプトはFALSE値として解釈されるため、対応する行または要素が削除されます。デフォルト値はFALSEです。

ore.parallel

埋込みRの実行で使用する優先並列度。次のうちの1つ。

- 特定の並列度では、2以上の正の整数

- パラレル化しない場合は、FALSEまたは1

- data引数のデフォルトのパラレル化の場合はTRUE

- 操作に対するデータベースのデフォルトはNULL

デフォルト値はNULLです。

ore.sep

ore.frameの複数列の行名間で使用するセパレータを指定する文字列。デフォルト値は|です。

ore.trace

Oracle R Enterpriseの反復関数が反復ごとに出力を印刷するかどうかを示す論理値。デフォルト値はFALSEです。

ore.warn.order

順序付けが必要な関数で行名がないore.frameまたは要素名がないore.vectorを使用したときにOracle R Enterpriseが警告メッセージを表示するかどうかを指定する論理値。デフォルト値はTRUEです。

関連項目:

- ore.sepおよびore.warn.orderの使用の詳細は、「順序付けに関連するグローバル・オプション」を参照してください。

- 「パラレル実行のサポート」

Oracle R Enterpriseの例

Oracle R Enterpriseには、Oracle R Enterpriseの関数の使用を示すいくつかのサンプル・スクリプトが含まれています。この項には次のトピックが含まれます:

- Oracle R Enterpriseの例のリスト

- Oracle R Enterpriseのサンプル・スクリプトの実行

関連項目:

- 「Oracle R Enterpriseのオンライン・リソース」

Oracle R Enterpriseの例のリスト

例1-7に示すとおり、demo関数を使用してOracle R Enterpriseのサンプル・スクリプトのリストを表示できます。

例1-7 Oracle R Enterpriseの例をリストするためのデモの使用方法

demo(package = "ORE")

例1-7のリスト

R> demo(package = "ORE")

Demos in package 'ORE':

aggregate      Aggregation
analysis       Basic analysis & data processing operations
basic          Basic connectivity to database
binning        Binning logic
columnfns      Column functions
cor            Correlation matrix
crosstab       Frequency cross tabulations
datastore      DataStore operations
datetime       Date/Time operations
derived        Handling of derived columns
distributions  Distribution, density, and quantile functions
do_eval        Embedded R processing
esm            Exponential smoothing method
freqanalysis   Frequency cross tabulations
glm            Generalized Linear Models
graphics       Demonstrates visual analysis
group_apply    Embedded R processing by group
hypothesis     Hyphothesis testing functions
matrix         Matrix related operations
nulls          Handling of NULL in SQL vs. NA in R
odm_ai         Oracle Data Mining: attribute importance
odm_ar         Oracle Data Mining: association rules
odm_dt         Oracle Data Mining: decision trees
odm_glm        Oracle Data Mining: generalized linear models
odm_kmeans     Oracle Data Mining: enhanced k-means clustering
odm_nb         Oracle Data Mining: naive Bayes classification
odm_nmf        Oracle Data Mining: non-negative matrix factorization
odm_svm        Oracle Data Mining: support vector machines
push_pull      RDBMS <-> R data transfer
rank           Attributed-based ranking of observations
reg            Ordinary least squares linear regression
row_apply      Embedded R processing by row chunks
sampling       Random row sampling and partitioning of an ore.frame
sql_like       Mapping of R to SQL commands
stepwise       Stepwise OLS linear regression
summary        Summary functionality
table_apply    Embedded R processing of entire table

Oracle R Enterpriseのサンプル・スクリプトの実行

Oracle R Enterpriseのサンプル・スクリプトはdemo関数を使用して実行できます。ほとんどの例では、R Distributionに含まれているdatasetsパッケージにあるirisデータセットを使用します。

サンプル・スクリプトを実行するには、Rを起動し、OREパッケージをlibrary(ORE)を指定してロードし、データベースに接続してから、demo関数を使用します。

例1-8では、basic.Rサンプル・スクリプトを実行します。例の後にあるリストには、スクリプトの出力の最初の数行のみが表示されています。このスクリプトはメモリーないデータベース・オブジェクトであるIRIS_TABLEを作成しますが、これはore.frameオブジェクトです。このスクリプトは次に、irisのdata.frameおよびIRIS_TABLEのore.frameが同じ構造を持ち、同じデータを含んでいることを示します。

例1-8 basic.Rサンプル・スクリプトの実行

demo("basic", package = "ORE")

例1-8のリスト

R> demo("basic", package = "ORE")

demo(basic)
---- ~~~~~

Type  <Return>   to start :

R> #
R> #     O R A C L E  R  E N T E R P R I S E  S A M P L E   L I B R A R Y
R> #
R> #     Name: basic.R
R> #     Description: Demonstrates basic connectivity to database
R> #
R> #
R> #
R>
R> ## Set page width
R> options(width = 80)

R> # Push the built-in iris data frame to the database
R> IRIS_TABLE <- ore.push(iris)

R> # Display the class of IRIS_TABLE
R> class(IRIS_TABLE)
[1] "ore.frame"
attr(,"package")
[1] "OREbase"

R> # Basic commands
R>
R> # Number of rows
R> nrow(iris)
[1] 150

R> nrow(IRIS_TABLE)
[1] 150

R> # Column names of the data frame
R> names(iris)
[1] "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width"  "Species"

R> names(IRIS_TABLE)
[1] "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width"  "Species"

# The rest of the output is not shown.

関連項目:

- Oracle R Enterpriseの基本的な関数の使用については、第2章「Oracle R Enterpriseの概要」を参照してください。

2 Oracle R Enterpriseの概要

この章では、Oracle Databaseインスタンスに接続し、Oracle R Enterpriseオブジェクトを作成してデータベースに格納することによってOracle R Enterpriseの使用を開始する方法を説明します。

この章の内容は次のとおりです。

- Oracle Databaseインスタンスへの接続

- Oracle DatabaseでのRオブジェクトの作成および管理

Oracle Databaseインスタンスへの接続

Oracle R Enterpriseを使用するには、まず、次の各項の説明に従ってOracle Databaseインスタンスに接続します。

- データベースへの接続について

- ore.connect関数およびore.disconnect関数の使用方法

データベースへの接続について

Oracle R Enterpriseクライアント・コンポーネントによって、RセッションがOracle DatabaseインスタンスおよびOracle R Enterprise Serverコンポーネントに接続されます。この接続によってRユーザーはデータベース・スキーマ内のデータを使用できます。さらに、データベース・サーバーの処理能力、メモリーおよび記憶域容量もRセッションで使用できるようになります。

この項の内容は次のとおりです。

- ore.connect関数の使用について

- ore.disconnect関数の使用について

ore.connect関数の使用について

Oracle R Enterpriseの使用を開始するには、最初にore.connect関数を使用してOracle Databaseインスタンスのスキーマに接続します。Rセッション中に同時に存在できるのは、1つのOracle R Enterprise接続のみです。Rセッションがすでにデータベースに接続されている場合にore.connectを呼び出すと、アクティブな接続を終了してから新しい接続を開きます。接続を試みる前に、is.ore.connected関数を使用してアクティブな接続が存在するかどうかを確認できます。

ore.disconnect関数を使用して明示的に接続を終了します。ore.disconnectを呼び出さない場合は、Rセッションの終了時に接続が自動的に終了されます。ore.disconnectの詳細は、「ore.disconnect関数の使用について」を参照してください。

ore.connectのtype引数を使用して、接続のタイプ(ORACLEまたはHIVE)を指定します。HIVE接続タイプは、HadoopクラスタのHive表に接続します。ORACLE接続タイプは、Oracle Databaseインスタンスのスキーマに接続します。typeのデフォルト値はORACLEです。

接続タイプがHIVEの場合、ore.connectは他の引数をすべて無視します。HadoopおよびHiveのOracle R Connectorの詳細は、Oracle Big Data Connectorsユーザーズ・ガイドを参照してください。HIVEオプションは、Oracle R Advanced Analytics for Hadoop (ORAAH)をHadoopクラスタとともに使用している場合にのみ適用されます。ORAAHは、Big Data Applianceに対するOracle Big Data Connectorsオプションの一部です。

接続タイプがORACLEの場合は、次を実行します。

- 論理引数allを使用して、Oracle R Enterpriseがスキーマ内でユーザーがアクセス権を持つ各表に対してore.frameオブジェクトを自動的に作成し、作成したore.frameオブジェクトを現在のRセッションで表示するかどうかを指定します。ore.frameオブジェクトには表に関するメタデータが含まれます。all引数のデフォルト値はFALSEです。
all = TRUEの場合、Oracle R Enterpriseはore.sync関数およびore.attach関数を暗黙的に呼び出します。all = FALSEの場合は、ユーザーはore.syncを明示的に呼び出してore.frameオブジェクトを作成する必要があります。これらのオブジェクトに名前でアクセスするには、ユーザーはore.attachを呼び出して、検索パスにその名前を含める必要があります。これらの関数の詳細は、「データベース内データ用のRオブジェクトの作成」を参照してください。

- conn_string引数、またはuser、sid、host、password、port、service_nameおよびconn_stringの引数の様々な組合せを使用して、接続を特定する情報を指定します。
クリアテキスト・パスワードを使用しないようにするには、conn_string引数を使用してOracleウォレットのパスワードを指定できます。その他の引数は必要ありません。Oracleウォレットのパスワードを指定することで、アプリケーション・コード、バッチ・ジョブまたはスクリプトへのデータベース・ユーザーのパスワードの埋込みを避けることができます。Oracleウォレットの使用の詳細は、『Oracle Databaseセキュリティ・ガイド』を参照してください。

その他の接続識別子の引数を使用する場合は、データベース・ユーザー名、ホスト名およびパスワード、システム識別子(SID)またはサービス名のいずれか、さらにオプションでTCPポートを指定するか、データベース・ユーザー名、パスワードおよびconn_string引数を指定します。

port引数のデフォルト値は1521、hostのデフォルト値はlocalhost (ローカル・ホストを指定します)、conn_stringのデフォルト値はNULLです。接続するOracle Databaseインスタンスと同じコンピュータ上でRセッションを実行している場合は、ローカル・ホストを指定します。

関連項目:

- 各種の接続識別子の使用例は、「ore.connect関数およびore.disconnect関数の使用方法」を参照してください。

- 「データベース内データ用のRオブジェクトの作成」

ore.disconnect関数の使用について

RセッションとOracle Databaseインスタンス間の接続を明示的に終了するには、ore.disconnect関数を呼び出します。次のいずれかを実行した場合、Oracle R Enterpriseはore.disconnectを暗黙的に呼び出します。

- Rセッションの終了

- Oracle R Enterprise接続がすでにアクティブな場合のore.connectの呼出し

アクティブな接続を切断すると、Oracle R Enterpriseは、Oracle R Enterpriseデータストアに明示的に保存されていないすべてのOracle R Enterpriseオブジェクトを破棄します。オブジェクトの保存の詳細は、「データベースでのRオブジェクトの保存および管理」を参照してください。

ore.connect関数およびore.disconnect関数の使用方法

この項の例では、接続を指定するための様々な方法を示します。

例2-1では、接続が存在するかどうかを最初に確認します。次に、ore.connect関数がuser、sid、hostおよびpasswordの引数として受け入れる値を使用します。この例では、接続を終了してから、別のユーザーで同じデータベース・インスタンスに接続します。

例2-1 ore.connectの使用方法およびSIDの指定

if (!is.ore.connected())
ore.connect("rquser", "sales", "sales-server", "rquserStrongPassword")
ore.disconnect()
ore.connect("diffuser", "sales", "sales-server", "diffuserStrongPassword")

例2-2では、SIDではなくサービス名の使用を示します。さらに、ローカル・ホストへの接続も指定します。

例2-2 ore.connectの使用方法およびサービス名の指定

ore.connect("rquser", host = "localhost", password = "rquserStrongPassword",
service_name = "sales.example.com")

例2-3では、conn_string引数を使用して、接続を特定する簡単な接続文字列を指定します。

例2-3 ore.connectの使用方法および簡単な接続文字列の指定

ore.connect(user = "rquser", password = "rquserStrongPassword",
conn_string = "sales-server:1521:sales
(ADDRESS=(PROTOCOL=tcp) (HOST=sales-server) (PORT=1521))
(CONNECT_DATA=(SERVICE_NAME=sales.example.com)))")

例2-4では、conn_string引数を使用して、接続を特定する完全な接続文字列を指定します。

例2-4 ore.connectの使用方法および完全な接続文字列の指定

ore.connect(user = "rquser", password = "rquserStrongPassword",
conn_string = "DESCRIPTION=
(ADDRESS=(PROTOCOL=tcp) (HOST=sales-server) (PORT=1521))
(CONNECT_DATA=(SERVICE_NAME=myserver.example.com)))")

例2-5では、空の接続文字列を使用してローカル・ホストに接続します。次に、接続を明示的に終了します。

例2-5 ore.connectの使用方法および空の接続文字列の指定

ore.connect(user = "rquser", password = "rquserStrongPassword", conn_string = "")
ore.disconnect()

Oracle DatabaseでのRオブジェクトの作成および管理

透過層関数を使用すると、Oracle Databaseインスタンスに接続してデータベース・スキーマ内のデータ構造と相互作用できます。データベースに対してデータを移動でき、データベース表を作成できます。さらに、Rオブジェクトをデータベースに保存できます。これらのアクションを実行するOracle R Enterpriseの関数については、次の各項で説明します。

- データベース内データ用のRオブジェクトの作成

- データベースに対するデータの移動

- データベース表の作成および削除

- データベースでのRオブジェクトの保存および管理

データベース内データ用のRオブジェクトの作成

次の各項で説明するとおり、Oracle R Enterpriseを使用して、Rセッションにデータベース常駐データからRプロキシ・オブジェクトを作成できます。

- データベース・オブジェクト用Rオブジェクトの作成について

- ore.sync関数の使用方法

- ore.get関数の使用方法

- ore.attach関数の使用方法

データベース・オブジェクト用Rオブジェクトの作成について

Rセッションでore.connectを呼び出すと、Oracle R EnterpriseはOracle Databaseインスタンス内のスキーマへの接続を作成します。そのスキーマ内のデータベース表のデータへのアクセスを取得するには、ore.sync関数を使用します。この関数は、スキーマ内の表のプロキシであるore.frameオブジェクトを作成します。ore.attach関数を使用して、R検索パスにスキーマを表すR環境を追加できます。データベースへの接続の詳細は、「Oracle Databaseインスタンスへの接続」を参照してください。

ore.sync関数を使用して、データベース表のプロキシとしてore.frameオブジェクトを作成する場合、ore.frameプロキシ・オブジェクトの名前はデータベース・オブジェクトの名前と同じです。各ore.frameプロキシ・オブジェクトには、対応するデータベース・オブジェクトに関するメタデータが含まれます。

このプロキシore.frameオブジェクトを使用して、表からデータを選択できます。表からデータを選択するR操作を実行すると、操作によってデータベース・オブジェクトから現在のデータが返されます。ただし、一部のアプリケーションが表に列を追加したか、データベース・オブジェクトのメタデータを変更した場合、そのデータベース・オブジェクトに対して再びore.syncが呼び出されるまでore.frameプロキシ・オブジェクトは変更を反映しません。

表を指定せずにore.sync関数を呼び出した場合、およびOracle Databaseインスタンスへの接続を確立したore.connect関数呼出しでall引数がFALSEだった場合は、ore.sync関数がore.connectに指定されたスキーマ内の各表にプロキシ・オブジェクトを作成します。table引数を使用してore.frameプロキシ・オブジェクトを作成する表を指定できます。

ヒント:
メモリー・リソースおよび時間を節約するには、Rセッションで使用する表にプロキシのみを追加してください。

schema引数を使用して、R環境およびプロキシ・オブジェクトを作成するスキーマを指定できます。指定したデータベース・スキーマに一度に存在できるのは、1つの環境のみです。use.keys引数を使用すると、ore.frameオブジェクトを順序付けするために表で主キーを使用するかどうかを指定できます。

ヒント:
順序付けはデータベースに負荷がかかります。Rでのほとんどの操作には順序付けは不要なため、データのサンプリングやその他の目的で必要な場合を除いて、通常はuse.keysをFALSEに設定してください。順序付けの詳細は、「序付けられたおよび順序付けられていないore.frameオブジェクトの作成」を参照してください。

ore.ls関数を使用して、スキーマの環境内のデータベース表に対応するore.frameプロキシ・オブジェクトをリストできます。ore.exists関数を使用して、データベース表のore.frameプロキシ・オブジェクトがR環境に存在するかどうかを確認できます。プロキシ・オブジェクトが存在する場合はTRUEが、存在しない場合はFALSEが関数によって返されます。ore.rm関数を使用してR環境からore.frameプロキシ・オブジェクトを削除できます。

ore.sync関数の使用方法

例2-6にore.sync関数の使用を示します。この例では、最初にore.syncを呼び出して現在のスキーマに3つの表を指定しますが、この関数はrquserスキーマにR環境を作成し、そのスキーマの指定した表にプロキシore.frameオブジェクトを作成します。この例では、現在の環境にあるore.frameプロキシ・オブジェクトをリストします。次に、ore.syncを再び呼び出し、そのスキーマ内の指定した表に対する環境に、SHスキーマおよびプロキシ・オブジェクト用のR環境を作成します。この例では、ore.exists関数を呼び出して、指定された表が現在の環境に存在するかどうかを確認した後に、SH環境に存在するかどうかを確認します。その後、rquser環境から表を削除して、その環境にあるプロキシ・オブジェクトをリストします。

例2-6 ore.frameプロキシ・オブジェクトをR環境に追加するためのore.syncの使用方法

# After connecting to a database as rquser. The tables TABLE1, TABLE2, TABLE3,
# and TABLE4 exist in the rquser schema.
# Create ore.frame objects for the specified tables.
ore.sync(table = c("TABLE1", "TABLE3", "TABLE4"))
# List the ore.frame proxy objects in the current environment.
ore.ls()
# The rquser user has been granted SELECT permission on the tables in the
# SH schema.
ore.sync("SH", table = c("CUSTOMERS", "SALES"))
# Find out if the CUSTOMERS ore.frame exists in the rquser environment.
ore.exists("CUSTOMERS")
# Find out if it exists in the SH environment.
ore.exists("CUSTOMERS", schema = "SH")
# List the ore.frame proxy objects in the SH environment.
ore.ls("SH")
# Remove the ore.frame proxy object for TABLE4 from the current environment.
ore.rm("TABLE4")
# List the ore.frame proxy objects in the current environment again.
ore.ls()

例2-6のリスト

R> # After connecting to a database as rquser. The tables TABLE1, TABLE2, TABLE3,
R> # and TABLE4 exist in the rquser schema.
R> # Create ore.frame objects for the specified tables.
R> ore.sync(table = c("TABLE1", "TABLE3", "TABLE4"))
R> # List the ore.frame proxy objects in the current environment.
R> ore.ls()
[1] "TABLE1"     "TABLE3"     "TABLE4"
R> # The rquser user has been granted SELECT permission on the tables in the
R> # SH schema.
R> ore.sync("SH", table = c("CUSTOMERS", "SALES"))
R> # Find out if the CUSTOMERS ore.frame exists in the rquser environment.
R> ore.exists("CUSTOMERS")
[1] FALSE
R> # Find out if it exists in the SH environment.
R> ore.exists("CUSTOMERS", schema = "SH")
[1] TRUE
R> # List the ore.frame proxy objects in the SH environment.
R> ore.ls("SH")
[1] "CUSTOMERS" "SALES"
R> # Remove the ore.frame proxy object for TABLE4 from the current environment.
R> ore.rm("TABLE4")
R> # List the ore.frame proxy objects in the current environment again.
R> ore.ls()
[1] "TABLE1"     TABLE3"

ore.get関数の使用方法

ore.syncを使用してR環境およびore.frameプロキシ・オブジェクトを作成した後に、例2-7に示すように、ore.get関数を使用してプロキシ・オブジェクトを名前を指定して取得できます。この例では、ore.sync関数を呼び出して、SHスキーマのCUSTOMERS表のプロキシであるore.frameオブジェクトを作成します。次に、そのプロキシ・オブジェクトのディメンションを取得します。

例2-7 データベース表を取得するためのore.getの使用方法

ore.sync(schema = "SH", table = "CUSTOMERS", use.keys = FALSE)
dim(ore.get(name = "CUSTOMERS", schema = "SH"))

例2-7のリスト

R> ore.sync(schema = "SH", table = "CUSTOMERS", use.keys = FALSE)
R> dim(ore.get(name = "CUSTOMERS", schema = "SH"))
[1] 630  15

SH_CUST <- ore.get(name = "CUSTOMERS", schema = "SH")のようにore.getを使用して、表のプロキシore.frameを取得し、それをRで変数に割り当てることができます。ore.frameはRブローバル環境に存在し、この環境は.GlobalEnvを使用して参照できるため、ls関数によって返されるリストに表示されます。また、このオブジェクトはRグローバル環境に存在するため、データベース・スキーマを表すR環境とは対照的に、ore.ls関数によってリストされません。

ore.attach関数の使用方法

ore.attachを使用して、データベース・スキーマのR環境をR検索パスに追加します。R環境を追加すると、スキーマ環境を指定することなくore.sync関数で作成したプロキシ・オブジェクトを介してデータベース表に名前を指定してアクセスできます。

デフォルト・スキーマは接続作成時に指定したもので、検索パスでのデフォルト位置は2です。スキーマおよび位置はore.attach関数呼出しで指定できます。また、環境の追加時に名前の競合が発生するかどうかをore.attach関数で示すかどうかを指定できます。ore.detach関数を使用して、R検索パスからスキーマに対する環境をデタッチできます。

例2-8にore.attach関数の使用を示します。例にあるコメントは、関数の呼出しを説明しています。

例2-8 データベース・スキーマの環境を追加するためのore.attachの使用方法

# Connected as rquser.
# Add the environment for the rquser schema to the R search path.
ore.attach()
# Create an unordered ore.frame proxy object in the SH environment for the
# specifed table.
ore.sync(schema = "SH", table = "CUSTOMERS", use.keys = FALSE)
# Add the environment for the SH schema to the search path and warn if naming
# conflicts exist.
ore.attach("SH", 3, warn.conflicts = TRUE)
# Display the number of rows and columns in the proxy object for the table.
dim(CUSTOMERS)
# Remove the environment for the SH schema from the search path.
ore.detach("SH")
# Invoke the dim function again.
dim(CUSTOMERS)

例2-8のリスト

R> # Connected as rquser.
R> # Add the environment for the rquser schema to the R search path.
ore.attach()
R> # Create an unordered ore.frame proxy object in the SH environment for the
R> # specifed table.
R> ore.sync(schema = "SH", table = "CUSTOMERS", use.keys = FALSE)
R> # Add the environment for the SH schema to the search path and warn if naming
R> # conflicts exist.
R> ore.attach("SH", 3, warn.conflicts = TRUE)
R> # Display the number of rows and columns in the proxy object for the table.
R> dim(CUSTOMERS)
[1] 630  15
R> # Remove the environment for the SH schema from the search path.
R> ore.detach("SH")
R> # Invoke the dim function again.
R> dim(CUSTOMERS)
Error: object 'CUSTOMERS' not found

順序付けられたおよび順序付けられていないore.frameオブジェクトの作成

Oracle R Enterpriseでは、順序付けられたまたは順序付けられていないore.frameオブジェクトを作成できます。次の各項目でこの機能について説明します。

- ore.frameオブジェクトの順序付けについて

- 順序付けに関連するグローバル・オプション

- キーを使用した順序付け

- 行名を使用した順序付け

- 順序付けられたフレームの使用方法

ore.frameオブジェクトの順序付けについて

vectorやdata.frameなどのRオブジェクトには、その要素の暗黙的な順序付けがあります。Oracle Database表のデータは、必ずしも順序付けられている必要はありません。一部のR操作では順序付けは役立ちますが、他の操作では必要ではありません。ore.frameを順序付けすることで、整数または文字列索引のいずれかを使用してore.frameオブジェクトに索引付けできます。

SQL問合せに対するプロキシである順序付けられたore.frameオブジェクトを使用すると、大規模なデータセットでは時間がかかります。そのため、Oracle R Enterpriseはデフォルトで順序付けられたore.frameオブジェクトの作成を試みますが、順序付けられていないore.frameオブジェクトを作成するための方法も提供されています。

SQL問合せのプロキシとしてOracle R Enterpriseのore.frameオブジェクトを作成するためにore.sync関数を呼び出す場合、use.keys引数を使用してore.frameを順序付けするか、しないようにするかを指定できます。

次の1つ以上の条件を満たす場合、ore.frameオブジェクトは順序付けられます。

- ore.sync関数のuse.keys引数の値がTRUEで、基礎となる表で主キーが定義されている

- ore.frameの行名が一意のタプルを構成する

- ore.frameオブジェクトがaggregateやcbindなどの特定の関数で生成されている

- 関連するOracle R Enterpriseの関数に対する入力引数であるore.frameオブジェクトのすべてが順序付けられている

次の1つ以上の条件を満たす場合、ore.frameオブジェクトは順序付けられません。

- ore.sync関数のuse.keys引数の値がFALSEである

- 主キーが基礎となる表に定義されておらず、ore.frameオブジェクトの行名が指定されていないか、ore.frameオブジェクトの行名がNULLに設定されている

- 関連するOracle R Enterpriseの関数に対する入力引数である1つ以上のore.frameオブジェクトが順序付けられていない

順序付けられていないore.frameオブジェクトにはNULLの行名があります。例2-9の最後の行に示すとおり、オブジェクトの行名でis.nullを呼び出すことによってore.frameオブジェクトが順序付けられるかどうかを判断できます。ore.frameオブジェクトが順序付けられていない場合、is.nullはエラーを返します。

関連項目:
「データの索引付け」

順序付けに関連するグローバル・オプション

Oracle R Enterpriseには、ore.frameオブジェクトの順序付けに関連するオプションがあります。ore.warn.orderグローバル・オプションは、順序付けが必要な関数で順序付けられていないore.frameオブジェクトを使用した場合にOracle R Enterpriseが警告メッセージを表示するかどうかを指定します。操作で期待される内容がわかっている場合は、出力に表示されないように警告を無効化する必要がある場合があります。警告メッセージの例については、例2-9および例2-10を参照してください。

次の例に示すとおり、現在の設定を確認したり、このオプションを有効化または無効化できます。

R> options("ore.warn.order")
$ore.warn.order
[1] TRUE
R> options("ore.warn.order" = FALSE)
R> options("ore.warn.order" = TRUE)

ore.sepオプションを使用すると、次の例に示すとおり、複数列キーに使用する行名の値の間にセパレータを指定できます。

R> options("ore.sep")
$ore.sep
[1] "|"

R> options("ore.sep" = "/")
R> options("ore.sep" = "|")

キーを使用した順序付け

例2-9に示すとおり、データベース表の主キーを使用してore.frameオブジェクトを順序付けできます。この例では、スパム・データセットをkernlabパッケージからロードします。これによってデータセットから2つの表が作成され、その後、SPAM_PK表に主キーが追加されます。この例には各表の最初の8行が表示されています。SPAM_PK表のプロキシ・オブジェクトは、順序付けられたore.frameオブジェクトです。これには、|文字で区切られたTSとUSERIDの行値の組合せである行名があります。SPAM_NOPK表のプロキシ・オブジェクトは順序付けられていないore.frameオブジェクトで、これには記号SPAM_NOPKが付けられます。デフォルトで、SPAM_NOPKには連番の行名が付けられます。

例2-9 キーを使用した順序付け

# Prepare the data.
library(kernlab)
data(spam)
s <- spam
# Create a column that has integer values.
s$TS <- 1001:(1000 + nrow(s))
# Create a column that has integer values with each number repeated twice.
s$USERID <- rep(351:400, each=2, len=nrow(s))
# Ensure that the database tables do not exist.
ore.drop(table='SPAM_PK')
ore.drop(table='SPAM_NOPK')
# Create database tables.
ore.create(s[,c(59:60,1:28)], table="SPAM_PK")
ore.create(s[,c(59:60,1:28)], table="SPAM_NOPK")
# Using a SQL statement, alter the SPAM_PK table to add a composite primary key.
ore.exec("alter table SPAM_PK add constraint SPAM_PK primary key
(\"USERID\",\"TS\")")
# Synchronize the table to get the change to it.
ore.sync(table = "SPAM_PK")
# View the data in the tables.
# The row names of the ordered SPAM_PK are the primary key column values.
head(SPAM_PK[,1:8])
# The row names of the unordered SPAM_NOPK are sequential numbers.
# The first warning results from the inner accessing of SPAM_NOPK to subset
# the columns. The second warning is for the invocation of the head
# function on that subset.
head(SPAM_NOPK[,1:8])
# Verify that SPAM_NOPK is unordered.
is.null(row.names(SPAM_NOPK))

例2-9のリスト

R> # Prepare the data.
R> library(kernlab)
R> data(spam)
R> s <- spam
R> # Create a column that has integer values.
R> s$TS <- 1001:(1000 + nrow(s))
R> # Create a column that has integer values with each number repeated twice.
R> s$USERID <- rep(351:400, each=2, len=nrow(s))
R> # Ensure that the database tables do not exist.
R> ore.drop(table='SPAM_PK')
R> ore.drop(table='SPAM_NOPK')
R> # Create database tables.
R> ore.create(s[,c(59:60,1:28)], table="SPAM_PK")
R> ore.create(s[,c(59:60,1:28)], table="SPAM_NOPK")
R> # Using a SQL statement, alter the SPAM_PK table to add a composite primary key.
R> ore.exec("alter table SPAM_PK add constraint SPAM_PK primary key
+  (\"USERID\",\"TS\")")
R> # Synchronize the table to get the change to it.
R> ore.sync(table = "SPAM_PK")
R> # View the data in the tables.
R> # The row names of the ordered SPAM_PK are the primary key column values.
R> head(SPAM_PK[,1:8])
TS USERID make address  all num3d  our over
1001|351 1001    351 0.00    0.64 0.64     0 0.32 0.00
1002|351 1002    351 0.21    0.28 0.50     0 0.14 0.28
1003|352 1003    352 0.06    0.00 0.71     0 1.23 0.19
1004|352 1004    352 0.00    0.00 0.00     0 0.63 0.00
1005|353 1005    353 0.00    0.00 0.00     0 0.63 0.00
1006|353 1006    353 0.00    0.00 0.00     0 1.85 0.00
R> # The row names of the unordered SPAM_NOPK are sequential numbers.
R> # The first warning results from the inner accessing of SPAM_NOPK to subset
R> # the columns. The second warning is for the invocation of the head
R> # function on that subset.
R> head(SPAM_NOPK[,1:8])
TS USERID make address  all num3d  our over
1 1001    351 0.00    0.64 0.64     0 0.32 0.00
2 1002    351 0.21    0.28 0.50     0 0.14 0.28
3 1003    352 0.06    0.00 0.71     0 1.23 0.19
4 1004    352 0.00    0.00 0.00     0 0.63 0.00
5 1005    353 0.00    0.00 0.00     0 0.63 0.00
6 1006    353 0.00    0.00 0.00     0 1.85 0.00
Warning messages:
1: ORE object has no unique key - using random order
2: ORE object has no unique key - using random order
R> # Verify that SPAM_NOPK is unordered.
R> is.null(row.names(SPAM_NOPK))
Error: ORE object has no unique key

行名を使用した順序付け

例2-10に示すとおり、行名を使用してore.frameオブジェクトを順序付けできます。この例では、ローカルのRセッション・メモリーにdata.frameオブジェクトを作成し、それを記号aを付けてore.frameオブジェクト(Rセッションが接続されているOracle Databaseのメモリーにあります)にプッシュします。この例では、ore.frameオブジェクトにRのdata.frameオブジェクトのデフォルトの行名が付けられていることを示します。ore.frameが順序付けられているため、そこでrow.names関数を呼び出すと警告メッセージは生成されません。

この例では、例2-9のore.frameオブジェクトの順序付けられたSPAM_PKおよび順序付けられていないSPAM_NOPKを使用して、順序付けられていないSPAM_NOPKでrow.namesを呼び出すと警告メッセージが生成されますが、順序付けられているSPAM_PKでは生成されないことを示します。

SPAM_PKオブジェクトは行名で順序付けられていて、この行名は|文字で区切られたTSとUSERID列値を組み合せた値です。この例では、行名を変更できることを示します。

例2-10 行名を使用した順序付け

# Create an ordered ore.frame by default.
a <- ore.push(data.frame(a=c(1:10,10:1), b=letters[c(1:10,10:1)]))
# Display the values in the b column. Note that because the ore.frame is
# ordered, no warnings appear.
a$b
# Display the default row names for the first six rows of the a column.
row.names(head(a))
# SPAM_NOPK has no unique key, so row.names raises error messages.
row.names(head(SPAM_NOPK))
# Row names consist of TS &rsquor;|' USERID.
# For display on this page, only the first four row names are shown.
row.names(head(SPAM_PK))
# Reassign the row names to the TS column only
row.names(SPAM_PK) <- SPAM_PK$TS
# The row names now correspond to the TS values only.
row.names(head(SPAM_PK[,1:4]))
head(SPAM_PK[,1:4])

例2-10のリスト

R> # Create an ordered ore.frame by default.
R> a <- ore.push(data.frame(a=c(1:10,10:1), b=letters[c(1:10,10:1)]))
R> # Display the values in the b column. Note that because the ore.frame is
R> # ordered, no warnings appear.
R> a$b
[1] a b c d e f g h i j j i h g f e d c b aLevels: a b c d e f g h i j
R> # Display the default row names for the first six rows of the a column.
R> row.names(head(a))
[1] 1 2 3 4 5 6
R> # SPAM_NOPK has no unique key, so row.names raises error messages.
R> row.names(head(SPAM_NOPK))
Error: ORE object has no unique key
In addition: Warning message:
ORE object has no unique key - using random order
R> # Row names consist of TS &rsquor;|' USERID.
R> # For display on this page, only the first four row names are shown.
R> row.names(head(SPAM_PK))
1001|351         1002|351         1003|352         1004|352
"1001|3.51E+002" "1002|3.51E+002" "1003|3.52E+002" "1004|3.52E+002"
R> # Reassign the row names to the TS column only
R> row.names(SPAM_PK) <- SPAM_PK$TS
R> # The row names now correspond to the TS values only.
R> row.names(head(SPAM_PK[,1:4]))
[1] 1001 1002 1003 1004 1005 1006
R> head(SPAM_PK[,1:4])
TS USERID make address
1001 1001    351 0.00    0.64
1002 1002    351 0.21    0.28
1003 1003    352 0.06    0.00
1004 1004    352 0.00    0.00
1005 1005    353 0.00    0.00
1006 1006    353 0.00    0.00

順序付けられたフレームの使用方法

例2-11では、例2-9のore.frameオブジェクトの順序付けられたSPAM_PKおよび順序付けられていないSPAM_NOPKを使用して、2つの順序付けられたore.frameオブジェクトと2つの順序付けられていないore.frameオブジェクトのマージ結果を示します。

例2-11 順序付けられたおよび順序付けられていないore.frameオブジェクトのマージ

# Create objects for merging data from unordered ore.frame objects.
x <- SPAM_NOPK[,1:4]
y <- SPAM_NOPK[,c(1,2,4,5)]
m1 <- merge(x, y, by="USERID")
# The merged result m1 produces a warning because it is not an ordered frame.
head(m1,3)
# Create objects for merging data from ordered ore.frame objects.
x <- SPAM_PK[,1:4]
y <- SPAM_PK[,c(1,2,4,5)]
# The merged result m1 does not produce a warning now because it is an
# ordered frame.
m1 <- merge(x, y, by="USERID")
head(m1,3)

例2-11のリスト

R> # Create objects for merging data from unordered ore.frame objects.
R> x <- SPAM_NOPK[,1:4]
R> y <- SPAM_NOPK[,c(1,2,4,5)]
R> m1 <- merge(x, y, by="USERID")
R> # The merged result m1 produces a warning because it is not an ordered frame.
R> head(m1,3)
USERID TS.x make address.x TS.y address.y  all
1    351 5601 0.00         0 1001      0.64 0.64
2    351 5502 0.00         0 1001      0.64 0.64
3    351 5501 0.78         0 1001      0.64 0.64
Warning messages:
1: ORE object has no unique key - using random order
2: ORE object has no unique key - using random order
R> # Create objects for merging data from ordered ore.frame objects.
R> x <- SPAM_PK[,1:4]
R> y <- SPAM_PK[,c(1,2,4,5)]
R> # The merged result m1 does not produce a warning now because it is an
R> # ordered frame.
R> m1 <- merge(x, y, by="USERID")
R> head(m1,3)
USERID TS.x make address.x TS.y address.y  all
1001|1001    351 1001    0      0.64 1001      0.64 0.64
1001|1002    351 1001    0      0.64 1002      0.28 0.50
1001|1101    351 1001    0      0.64 1101      0.00 0.00

関連項目:
例3-4「ore.frameオブジェクトの索引付け」

データベースに対するデータの移動

ore.push関数を使用して、ローカルのRオブジェクトから一時データベース表、および対応するプロキシore.frameオブジェクトを作成できます。ore.pull関数を使用して、Oracle R Enterpriseプロキシ・オブジェクトが表すデータのコピーを含むローカルのRオブジェクトを作成できます。

ore.push関数は、Rオブジェクトを適切なデータ型のOracle R Enterpriseオブジェクトに変換します。ore.pull関数は、oreクラス・オブジェクトを取得してRオブジェクトを返します。入力オブジェクトがore.listの場合、ore.pull関数はdata.frameを作成し、各データベース列の各データを適切なR表現に変換します。

注意:
データがRセッション・メモリーに適合する場合にのみ、データをローカルRのdata.frameにプルできます。また、データがメモリーに適合しても非常に大きい場合は、多数の、またはすべてのR関数をクライアントRセッションで実行できない可能性があります。

例2-12は、Rのdata.frameオブジェクトを関連するore.frameオブジェクト(iris_of)とともに一時データベース表としてデータベースにプッシュし、iris_ofから1列を選択することによって別のore.frameオブジェクト(iris_of_setosa)を作成した後に、iris_of_setosaオブジェクトをdata.frameオブジェクトとしてローカルのRセッション・メモリーにプルすることを示します。この例では、一部のオブジェクトのクラスを表示します。

例2-12 データを移動するためのore.pushおよびore.pullの使用方法

class(iris)
# Push the iris data frame to the database.
iris_of <- ore.push(iris)
class(iris_of)
# Display the data type of the Sepal.Length column in the data.frame.
class(iris$Sepal.Length)
# Display the data type of the Sepal.Length column in the ore.frame.
class(iris_of$Sepal.Length)
# Filter one column of the data set.
iris_of_setosa <- iris_of[iris_of$Species == "setosa", ]
class(iris_of_setosa)
# Pull the selected column into the local R client memory.
local_setosa = ore.pull(iris_of_setosa)
class(local_setosa)

例2-12のリスト

R> class(iris)
[1] "data.frame"
R> # Push the iris data frame to the database.
R> iris_of <- ore.push(iris)
R> class(iris_of)
[1] "ore.frame"
attr(,"package")
[1] "OREbase"
R> # Display the data type of the Sepal.Length column in the data.frame.
R> class(iris$Sepal.Length)
[1] "numeric"
R> # Display the data type of the Sepal.Length column in the ore.frame.
R> class(iris_of$Sepal.Length)
[1] "ore.numeric"
attr(,"package")
[1] "OREbase"
R> # Filter one column of the data set.
R> iris_of_setosa <- iris_of[iris_of$Species == "setosa", ]
R> class(iris_of_setosa)
[1] "ore.frame"
attr(,"package")
[1] "OREbase"
R> # Pull the selected column into the local R client memory.
R> local_setosa = ore.pull(iris_of_setosa)
R> class(local_setosa)
[1] "data.frame"

明示的に保存しないかぎり、ore.push関数を使用して作成した一時データベース表および対応するOracle R Enterpriseプロキシ・オブジェクトは、Rセッションの終了時に破棄されます。

関連項目:

- データ型マッピングの詳細は、「Rのデータ型およびクラスの透過層サポート」を参照してください。

- データベースでのOracle R Enterpriseオブジェクトの永続的な保存の詳細は、「データベースでのRオブジェクトの保存および管理」を参照してください。

- push_pull.Rのスクリプト例

データベース表の作成および削除

ore.create関数を使用して、Oracle Databaseスキーマに永続表を作成できます。表を作成すると、データベース・スキーマを表すR環境に表のore.frameプロキシ・オブジェクトが自動的に作成されます。プロキシore.frameオブジェクトには表と同じ名前が付けられます。ore.drop関数を使用して、Oracle Databaseスキーマの永続表を削除できます。

注意:
ore.drop関数はデータベース表の削除にのみ使用してください。これを使用してore.frameオブジェクトを削除しないでください。ore.frameオブジェクトを削除するには、ore.rm関数を使用します。

例2-13では、データベースに表を作成し、その一部を削除します。

例2-13 表を作成および削除するためのore.createおよびore.dropの使用方法

# Create the ANIMALS_TABLE table from the Animals data.frame.
ore.create(Animals, table = "ANIMALS_TABLE")
# Create data.frame objects.
df1 <- data.frame(x1 = 1:5, y1 = letters[1:5])
df2 <- data.frame(x2 = 5:1, y2 = letters[11:15])
# Create the DF1_TABLE and DF2_TABLE tables from the data.frame objects.
ore.create(df1, "DF1_TABLE")
ore.create(df2, "DF2_TABLE")
# Create the CARS93_TABLE table from the Cars93 data.frame.
ore.create(Cars93, table = "CARS93_TABLE")
# List the Oracle R Enterprise proxy objects.
ore.ls()
# Drop the CARS93_TABLE object.
ore.drop(table = "CARS93_TABLE")
# List the Oracle R Enterprise proxy objects again.
ore.ls()

例2-13のリスト

R> # Create the ANIMALS_TABLE table from the Animals data.frame.
R> ore.create(Animals, table = "ANIMALS_TABLE")
R> # Create data.frame objects.
R> df1 <- data.frame(x1 = 1:5, y1 = letters[1:5])
R> df2 <- data.frame(x2 = 5:1, y2 = letters[11:15])
R> # Create the DF1_TABLE and DF2_TABLE tables from the data.frame objects.
R> ore.create(df1, "DF1_TABLE")
R> ore.create(df2, "DF2_TABLE")
R> # Create the CARS93_TABLE table from the Cars93 data.frame.
R> .create(Cars93, table = "CARS93_TABLE")
R> # List the Oracle R Enterprise proxy objects.
R> .ls()
[1] "ANIMALS_TABLE"  "CARS93_TABLE"  "DF1_TABLE"  "DF2_TABLE"
R> # Drop the CARS93_TABLE object.
R> ore.drop(table = "CARS93_TABLE")
R> # List the Oracle R Enterprise proxy objects again.
R> ore.ls()
[1] "ANIMALS_TABLE"  "DF1_TABLE"  "DF2_TABLE"

データベースでのRオブジェクトの保存および管理

Oracle R Enterpriseには、Oracle R Enterpriseプロキシ・オブジェクト、および任意のRオブジェクトをOracle Databaseに保存するために使用できるデータストアが用意されています。保存したオブジェクトを別のRセッションにリストアできます。データストアのオブジェクトは、RインタフェースおよびSQLインタフェースの両方を介して埋込みRの実行からもアクセスできます。

この項では、データストアの作成および管理に使用可能なOracle R Enterpriseの関数について説明します。この項の内容は次のとおりです。

- Oracle R Enterpriseオブジェクトの永続について

- Oracle R Enterpriseのデータストアについて

- データストアへのオブジェクトの保存

- データストアのコンテンツに関する情報の取得

- データストアからのオブジェクトのリストア

- データストアの削除

- 埋込みRの実行でのデータストアの使用について

Oracle R Enterpriseオブジェクトの永続について

Oracle R Enterpriseプロキシ・オブジェクトを含むRオブジェクトは、明示的に保存しないかぎり現行のRセッションの間存在します。Rオブジェクトの保存およびリストア用の標準のR関数(saveおよびload)は、ファイルに格納するためにRメモリー内のオブジェクトをシリアライズし、メモリーにリストアするためにデシリアライズします。ただし、Oracle R Enterpriseプロキシ・オブジェクトに対しては、それらの関数はプロキシ・オブジェクトに関連付けられているデータベース・オブジェクトをOracle Databaseに保存しないため、保存されたプロキシ・オブジェクトは別のRセッションでは正しく動作しません。

Oracle R Enterpriseプロキシ・オブジェクト、および任意のRオブジェクトは、ore.save関数を使用して保存できます。ore.save関数はOracle R Enterpriseデータストアを指定します。データストアは、Rセッションの終了時にデータベースに保持されます。データストアは、自身が含まれているオブジェクトの参照整合性を保持します。ore.load関数を使用して、データストア内のオブジェクトを別のRセッションにリストアできます。

データストアを使用して、次のことを実行できます。

- Oracle R Enterpriseおよび作成したその他のRオブジェクトを1つのRセッションに保存し、別のRセッションにリストアします。

- 埋込みRの実行で使用するためにR関数に引数を渡します。

- 埋込みRの実行で使用するためにオブジェクトを渡します。たとえば、関数をOREdmパッケージで使用してOracle Data Miningモデルを構築し、それをdatastoreに保存することもできます。その後、埋込みRの実行を介してそのモデルを使用してデータベースにデータをスコアリングできます。埋込みRの実行関数でのデータストアの使用例は、例6-7を参照してください。

表2-1にデータストアを操作する関数をリストし、その簡単な説明を示します。

表2-1 データストアを操作する関数

関数

説明

ore.save

Rオブジェクトを新規または既存のデータストアに保存します。

ore.load

データストアからオブジェクトをR環境にリストアします。

ore.lazyLoad

データストアからオブジェクトをR環境に遅延リストアします。

ore.delete

現行のOracle Databaseスキーマからデータストアを削除します。

ore.datastore

現行のOracle Databaseスキーマのデータストアに関する情報をリストします。

ore.datastoreSummary

現行のOracle Databaseスキーマの指定したデータストアに関する詳細な情報を提供します。

関連項目:
埋込みRの実行に対するRインタフェースおよびSQLインタフェースの使用に関する詳細は、第6章「Oracle R Enterpriseの埋込みRの実行の使用方法」を参照してください。

Oracle R Enterpriseのデータストアについて

各データベース・スキーマには、指定したOracle R Enterpriseデータストアを格納する表があります。データストアにはOracle R Enterpriseオブジェクトおよび標準のRオブジェクトを含めることができます。

ore.save関数を使用してデータストアを作成できます。データストアの作成時にそのデータストアの名前を指定します。オブジェクトを1つ以上のデータストアに保存できます。

データストアにデータベース・オブジェクトのOracle R Enterpriseプロキシ・オブジェクトが含まれているかぎり、データベース・オブジェクトはRセッション間で保持されます。たとえば、OREdmパッケージでore.odmNB関数を使用してOracle Data MiningのNaive Bayesモデルを構築することもできます。構築されたore.odmNBオブジェクトをデータストアに保存してRセッションを終了した場合、Oracle DatabaseはそのOracle Data Miningモデルを削除しません。ore.odmNBオブジェクトが含まれいるデータストアがない場合は、Rセッションを終了すると、データベースは自動的にそのモデルを削除します。

データストアへのオブジェクトの保存

ore.save関数は、1つ以上のRオブジェクトを指定されたデータストアに保存します。デフォルトでは、Oracle R Enterpriseは、現行のユーザー・スキーマにデータストアを作成します。ore.saveに対して引数を指定する場合、特定のオブジェクトの名前、またはオブジェクトのリストを指定できます。特定のR環境を指定して保存するオブジェクトを検索できます。overwriteおよびappendの引数は相互に排他的です。overwrite引数をTRUEに設定した場合、既存のデータストアを同じ名前の別のデータストアで置換できます。append引数をTRUEに設定した場合、既存のデータストアにオブジェクトを追加できます。description引数を使用すると、データストアの情報取得時に表示される説明テキストを指定できます。description引数は、append引数とともに使用すると機能しません。

例2-14に、引数の様々な組合せを使用したデータストアの作成を示します。

例2-14 オブジェクトの保存およびデータストアの作成

# Create some R objects.
df1 <- data.frame(x1 = 1:5, y1 = letters[1:5])
df2 <- data.frame(x2 = 5:1, y2 = letters[11:15])
iris_of <- ore.push(iris)

# Create a database table and an Oracle R Enterprise proxy object for the table.
ore.create(longley, table = "LONGLEY")

# List the R objects.
ls()

# List the Oracle R Enterprise proxy objects.
ore.ls()

# Save the proxy object and all objects in the current workspace environment
# to the datastore named ds1 and supply a description.
ore.save(LONGLEY, list = ls(), name = "ds1", description = "My datastore")

# Create some more objects.
x <- stats::runif(20)  # x is an object of type numeric.
y <- list(a = 1, b = TRUE, c = "hoopsa")
z <- ore.push(x)  # z is an object of type ore.numeric.

# Create another datastore.
ore.save(x, y, name = "ds2", description = "x and y")

# Overwrite the contents of datastore ds2.
ore.save(x, name = "ds2", overwrite = TRUE, description = "only x")

# Append object z to datastore ds2.
ore.save(z, name = "ds2", append = TRUE)

例2-14のリスト

R> # Create some R objects.
R> df1 <- data.frame(x1 = 1:5, y1 = letters[1:5])
R> df2 <- data.frame(x2 = 5:1, y2 = letters[11:15])
R> iris_of <- ore.push(iris)
R>
R> # Create a database table and an Oracle R Enterprise proxy object for the table.
R> ore.create(longley, table = "LONGLEY")
R>
R> # List the R objects.
R> ls()
[1] "df1"     "df2"     "iris_of"
R>
R> # List the Oracle R Enterprise proxy objects.
R> ore.ls()
[1] "LONGLEY"
R>
R> # Save the proxy object and all objects in the current workspace environment
R> # to the datastore named ds1 and supply a description.
R> ore.save(LONGLEY, list = ls(), name = "ds1", description = "My datastore")
R>
R> # Create some more objects.
R> x <- stats::runif(20)  # x is an object of type numeric.
R> y <- list(a = 1, b = TRUE, c = "hoopsa")
R> z <- ore.push(x)  # z is an object of type ore.numeric.
R>
R> # Create another datastore.
R> ore.save(x, y, name = "ds2", description = "x and y")
R>
R> # Overwrite the contents of datastore ds2.
R> ore.save(x, name = "ds2", overwrite = TRUE, description = "only x")
R>
R> # Append object z to datastore ds2.
R> ore.save(z, name = "ds2", append = TRUE)

データストアのコンテンツに関する情報の取得

ore.datastore関数およびore.datastoreSummary関数を使用することで、現行のユーザー・スキーマのデータストアに関する情報を取得できます。

ore.datastore関数を使用して、データストアに関する基本的な情報をリストできます。この関数は、データストア名、データストア内のオブジェクト数、データストアのサイズ、作成日および説明に対応する列を含んだdata.frameオブジェクトを返します。行は、列datastore.nameによってアルファベット順にソートされます。名前または正規表現パターンを使用してデータストアを検索できます。

例2-15にore.datastore関数の使用方法を示します。この例では、例2-14で作成したRオブジェクトの一部を使用します。

例2-15 ore.datastore関数の使用方法

# The datastore objects ds1 and ds2 and objects data.frame objects df1 and df2
# were created in Example 2-14.
ore.save(df1, df2, name = "dfobj", description = "df objects"
ore.save(x, y, z, name = "another_ds", description = "For pattern matching")

# List all of the datastore objects.
ore.datastore()

# List the specified datastore.
ore.datastore("ds1")

# List the datastore objects with names that include "ds".
ore.datastore(pattern = "ds")

例2-15のリスト

R> # The datastore objects ds1 and ds2 and objects data.frame objects df1 and df2
R> # were created in Example 2-14.
R> ore.save(df1, df2, name = "dfobj", description = "df objects"
R> ore.save(x, y, z, name = "another_ds", description = "For pattern matching")
R>
R> # List all of the datastore objects.
R> ore.datastore()
datastore.name object.count size       creation.date  description
1     another_ds            3 1217 2013-11-08 13:36:19 For pattern mattching
2          dfobj            2  656 2013-11-08 13:27:26            df objects
3            ds1            4 2908 2013-11-08 10:34:38          My datastore
4            ds2            2 1085 2013-11-08 10:46:08                only x

R> # List the specified datastore.
R> ore.datastore("ds1")
datastore.name object.count size       creation.date  description
1            ds1            4 2908 2013-11-08 10:41:09 My datastore
R>
R> # List the datastore objects with names that include "ds".
R> ore.datastore(pattern = "ds")
datastore.name object.count size       creation.date            description
1     another_ds            3 1217 2013-11-08 13:36:19  For pattern mattching
2            ds1            4 2908 2013-11-08 10:34:38           My datastore
3            ds2            2 1085 2013-11-08 10:46:08                 only x

ore.datastoreSummary関数は、接続されているデータベースのユーザー・スキーマにあるデータストアに保存されたRオブジェクトに関する情報を返します。この関数は、オブジェクト名、オブジェクト・クラス、オブジェクトのサイズおよびオブジェクトの長さ(vectorの場合)または行および列の数(data.frameオブジェクトの場合)に対応する列を含んだdata.frameを返します。データストアの名前を1つの引数として取ります。

例2-16にore.datastoreSummary関数の使用方法を示します。この例では、例2-14で作成したデータストアを使用します。

例2-16 ore.datastoreSummary関数の使用方法

ore.datastoreSummary("ds1")
ore.datastoreSummary("ds2")

例2-16のリスト

R> ore.datastoreSummary("ds1")
object.name      class size length row.count col.count
1 ANIMALS_TABLE  ore.frame  849      2        28         2
2           df1 data.frame  328      2         5         2
3           df2 data.frame  328      2         5         2
4       iris_of  ore.frame 1403      5       150         5
R> ore.datastoreSummary("ds2")
object.name       class size length row.count col.count
1           x     numeric  182     20        NA        NA
2           z ore.numeric  903     20        NA        NA

データストアからのオブジェクトのリストア

ore.load関数は、データストアに保存したRオブジェクトをRグローバル環境(.GlobalEnv)にリストアします。この関数は、リストアされるオブジェクトの名前を含む文字列ベクターを返します。

保存されたすべてのオブジェクトをロードするか、list引数を使用してロードするオブジェクトを指定できます。envir引数を使用すると、オブジェクトをロードする環境を指定できます。

例2-17に、例2-15で作成したデータストア・オブジェクトからオブジェクトをリストアするためのore.load関数の使用方法を示します。

例2-17 データストアからオブジェクトをリストアするためのore.load関数の使用方法

# We are in the same R session as Example 2-15. List the R objects.
ls()

# List the datastore objects.
ore.datastore()

# Delete the x and z objects.
ls()

# Restore all of the objects in datastore ds2.
ore.load("ds2")

ls()

# After ending the R session and starting another session.
ls()
# The datastore objects persist between sessions.
ore.datastore()

# Restore some of the objects from datastore ds1.
ore.load("ds1", list = c("df1", "df2", "iris_of"))
ls()

例2-17のリスト

R> # We are in the same R session as Example 2-15. List the R objects.
R> ls()
[1] "df1"     "df2"     "iris_of" "x"       "y"       "z"
R>
R> # List the datastore objects.
R> ore.datastore()
datastore.name object.count size       creation.date  description
1     another_ds            3 1217 2013-11-08 13:36:19 For pattern mattching
2          dfobj            2  656 2013-11-08 13:27:26            df objects
3            ds1            4 2908 2013-11-08 10:34:38          My datastore
4            ds2            2 1085 2013-11-08 10:46:08                only x
R>
R> # Delete the x and z objects.
R> ls()
[1] "df1"     "df2"     "iris_of" "y"
R>
R> # Restore all of the objects in datastore ds2.
R> ore.load("ds2")
[1] "x" "z"
R>
R> ls()
[1] "df1"     "df2"     "iris_of" "x"       "y"       "z"
R>
R> # After ending the R session and starting another session.
R> ls()
character(0)
R> # The datastore objects persist between sessions.
R> ore.datastore()
datastore.name object.count size       creation.date           description
1     another_ds            3 1217 2013-11-08 14:16:19 For pattern mattching
2          dfobj            2  656 2013-11-08 13:27:26            df objects
3            ds1            4 2908 2013-11-08 13:54:38          My datastore
4            ds2            2 1085 2013-11-08 10:46:08                only x

R> # Restore some of the objects from datastore ds1.
R> ore.load("ds1", list = c("df1", "df2", "iris_of"))
[1] "df1"     "df2"     "iris_of"
ls()
[1] "df1"     "df2"     "iris_of"

データストアの削除

ore.delete関数を使用すると、Oracle R Enterpriseデータストアのオブジェクトを削除、またはデータストア自身を削除できます。データストアを削除するには、名前を指定します。データストアから1つ以上のオブジェクトを削除するには、list引数を指定します。ore.delete関数は、削除したオブジェクトまたはデータストアの名前を返します。

例2-18に、データストアのオブジェクトを削除した後にデータストア全体を削除するためのore.deleteの使用方法を示します。この例では、例2-14で作成したオブジェクトを使用します。

例2-18 ore.delete関数の使用方法

# Delete the the df2 object from the ds1 datastore.
ore.delete("ds1", list = "df2")
# Delete the datastore named ds1.
ore.delete("ds1")

例2-18のリスト

R> # Delete the the df2 object from the ds1 datastore.
R> ore.delete("ds1", list = "df2")[1] "df2"
R> # Delete the datastore named ds1.
R> ore.delete("ds1")
[1] "ds1"

データストアを削除すると、Oracle R Enterpriseは、削除したデータストアでRオブジェクトによって参照されていたすべての一時データベース・オブジェクトを破棄します。Rオブジェクトを1つ以上のデータストアに保存していた場合、Oracle R Enterpriseは、一時データベース・オブジェクトを参照しているオブジェクトがないときにのみ、一時データベース・オブジェクトを破棄します。

埋込みRの実行でのデータストアの使用について

データストアにオブジェクトを保存することによって、埋込みRの実行関数への引数の引渡し、およびRオブジェクトの参照が非常に容易になります。1つのRセッションで作成したオブジェクトをデータベース内の単一のデータストアに保存できます。このデータストアの名前を埋込みR関数内でロードする引数として渡すことができます。データストアを使用して、1つのオブジェクトまたは複数のオブジェクトを簡単に渡すことができます。

関連項目:
埋込みRの実行に対するRインタフェースおよびSQLインタフェースの使用に関する詳細は、第6章「Oracle R Enterpriseの埋込みRの実行の使用方法」を参照してください。

3 データベースでのデータの準備および探索

この章では、分析用のデータを準備するためおよびデータの探索的分析を実行するためのOracle R Enterpriseオブジェクトの使用方法について説明します。これらの関数はすべて、モデリングのための非常に大規模なエンタープライズのデータベース常駐データの準備を容易にします。この章の内容は次のとおりです。

- Oracle R Enterpriseを使用したデータベースのデータの準備

- データの探索

- クライアントでのサード・パーティのパッケージの使用方法

Oracle R Enterpriseを使用したデータベースのデータの準備

Oracle R Enterpriseを使用して、次の各項の説明に従って、データベースで分析用のデータを準備できます。

- データベースでのデータの準備について

- データの選択

- データの索引付け

- データの結合

- データの集計

- データの変換

- データのサンプリング

- データのパーティショニング

- 時系列データの準備

データベースでのデータの準備について

Oracle R Enterpriseには、Rを使用して分析用のデータベース・データを準備できる関数が用意されています。これらの関数を使用して、ore.frameおよびその他のOracle R Enterpriseオブジェクトでの一般的なデータ準備タスクを実行できます。データ準備操作は、データベースにある大量のデータに対して実行でき、Comprehensive R Archive Network (CRAN)で入手可能なパッケージの関数を使用して分析用のローカルのRセッションに結果をプルできます。

データに対して次のような操作を実行できます。

- 選択

- ビニング

- サンプリング

- ソートおよび順序付け

- 集計

- 変換

- 日時データに対するデータ準備操作の実行

これらの操作の実行については、この章の他の項で説明します。

データの選択

分析用のデータの準備の一般的な手順は、大規模なデータセットから対象の値を選択またはフィルタ処理することです。この項の例には、ore.frameオブジェクトから列、行および値でのデータの選択を示します。

例3-1では、ore.frameオブジェクトから列を選択します。irisのdata.frameオブジェクトから、対応するプロキシore.frameオブジェクトのIRIS_TABLEとともに、データベース表を作成します。この例には、IRIS_TABLEの最初の6行が表示されています。この例ではIRIS_TABLEから2行を選択し、それを使用して順序付けられていないore.frameオブジェクトであるiris_projectedを作成します。順序付けられていないore.frameオブジェクトを使用したときに警告メッセージが表示されないように、ore.warn.orderグローバル・オプションをFALSEに設定します。その後、iris_projectedの最初の6行を表示します。

例3-1 列によるデータの選択

# Create a database table from the iris data set.
ore.create(iris, table ="IRIS_TABLE")
head(IRIS_TABLE, 3)

# Select columns from the table.
iris_projected = IRIS_TABLE[, c("Petal.Length", "Species")]

# Turn off warnings about using an unordered ore.frame.
options("ore.warn.order" = FALSE)
head (iris_projected)

例3-1のリスト

# Create a database table from the iris data set.
R> ore.create(iris, table ="IRIS_TABLE")
R> head(IRIS_TABLE, 3)
Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa
6          5.4         3.9          1.7         0.4  setosa

# Select columns from the table.
R> iris_projected = IRIS_TABLE[, c("Petal.Length", "Species")]

# Turn off warnings about using an unordered ore.frame.
R> options("ore.warn.order" = FALSE)

R> head (iris_projected)
Petal.Length Species
1          1.4  setosa
2          1.4  setosa
3          1.3  setosa
4          1.5  setosa
5          1.4  setosa
6          1.7  setosa

例3-2では、順序付けられているore.frameオブジェクトから行を選択します。この例では最初に、順序付けられたore.frameオブジェクトの作成に使用するために、irisのdata.frameオブジェクトに列を追加します。データベース表IRIS_TABLEが存在する場合は、ore.drop関数を呼び出して削除します。次に、irisのdata.frameから、対応するプロキシore.frameオブジェクトのIRIS_TABLEとともに、データベース表を作成します。例では、ore.exec関数を呼び出して、RID列をデータベース表の主キーにするためのSQL文を実行します。次にore.sync関数を呼び出して、IRIS_TABLEのore.frameオブジェクトをこの表と同期化させ、プロキシore.frameオブジェクトの最初の3行を表示します。

例3-2では次に、IRIS_TABLEから行番号で51行を選択し、それを使用して順序付けられたore.frameオブジェクトのiris_selrowsを作成します。この例では、iris_selrowsの最初の6行を表示します。その後、行名で3行を選択して結果を表示します。

例3-2 行によるデータの選択

# Add a column to the iris data set to use as row identifiers.
iris$RID <- as.integer(1:nrow(iris) + 100)
ore.drop(table = 'IRIS_TABLE')
ore.create(iris, table = 'IRIS_TABLE')
ore.exec("alter table IRIS_TABLE add constraint IRIS_TABLE
primary key (\"RID\")")
ore.sync(table = "IRIS_TABLE")
head(IRIS_TABLE, 3)

# Select rows by row number.
iris_selrows <- IRIS_TABLE[50:100,]
head(iris_selrows)

# Select rows by row name.
IRIS_TABLE[c("101", "151", "201"),]

例3-2のリスト

R> # Add a column to the iris data set to use as row identifiers.
R> iris$RID <- as.integer(1:nrow(iris) + 100)
R> ore.drop(table = 'IRIS_TABLE')
R> ore.create(iris, table = 'IRIS_TABLE')
R> ore.exec("alter table IRIS_TABLE add constraint IRIS_TABLE
+            primary key (\"RID\")")
R> ore.sync(table = "IRIS_TABLE")
R> head(IRIS_TABLE, 3)
Sepal.Length Sepal.Width Petal.Length Petal.Width Species RID
101          5.1         3.5          1.4         0.2  setosa 101
102          4.9         3.0          1.4         0.2  setosa 102
103          4.7         3.2          1.3         0.2  setosa 103
R> # Select rows by row number.
R> iris_selrows <- IRIS_TABLE[50:100,]
R> head(iris_selrows)
Sepal.Length Sepal.Width Petal.Length Petal.Width    Species RID
150          5.0         3.3          1.4         0.2     setosa 150
151          7.0         3.2          4.7         1.4 versicolor 151
152          6.4         3.2          4.5         1.5 versicolor 152
153          6.9         3.1          4.9         1.5 versicolor 153
154          5.5         2.3          4.0         1.3 versicolor 154
155          6.5         2.8          4.6         1.5 versicolor 155
R> # Select rows by row name.
R> IRIS_TABLE[c("101", "151", "201"),]
Sepal.Length Sepal.Width Petal.Length Petal.Width    Species RID
101          5.1         3.5          1.4         0.2     setosa 101
151          7.0         3.2          4.7         1.4 versicolor 151
201          6.3         3.3          6.0         2.5  virginica 201

例3-3に示すとおり、データセットの一部を選択できます。この例では、irisデータセットをデータベースにプッシュし、ore.frameオブジェクトのiris_ofを取得します。データをフィルタ処理してiris_of_filteredを生成しますが、これには、花弁の長さが1.5より短いもので、Sepal.Length列およびSpecies列にあるiris_ofの行の値が含まれています。この例ではさらに、条件を使用してデータをフィルタ処理して、setosa種または虹色の種で、花弁の幅が2.0より短いiris_ofの値がiris_of_filteredに含まれるようにします。

例3-3 値によるデータの選択

# Create a temporary database table from the iris data set and get an ore.frame.
iris_of <- ore.push(iris)
# Select Sepal.Length, Species from iris_of where Petal.Length < 1.5
iris_of_filtered <- iris_of[iris_of$Petal.Length < 1.5,
c("Sepal.Length", "Species")]
names(iris_of_filtered)
nrow(iris_of_filtered)
head(iris_of_filtered, 3)
# Alternate syntax filtering.
iris_of_filtered <- subset(iris_of, Petal.Length < 1.5)
nrow(iris_of_filtered)
head(iris_of_filtered, 3)
# Using the AND and OR conditions in filtering.
# Select all rows with either species = setosa OR species = versicolor
# and Petal.Width < 2.0
iris_of_filtered <- iris_of[(iris_of$Species == "setosa" |
iris_of$Species == "versicolor") &
iris_of$Petal.Width < 2.0,]
nrow(iris_of_filtered)
head(iris_of, 3)

例3-3のリスト

R> # Create a temporary database table from the iris data set and get an ore.frame.
R> iris_of <- ore.push(iris)
R> # Select Sepal.Length, Species from iris_of where Petal.Length < 1.5
R> iris_of_filtered <- iris_of[iris_of$Petal.Length < 1.5,
+                              c("Sepal.Length", "Species")]
R> names(iris_of_filtered)
[1] "Sepal.Length" "Species"
R> nrow(iris_of_filtered)
[1] 24
R> head(iris_of_filtered, 3)
Sepal.Length Species
1          5.1  setosa
2          4.9  setosa
3          4.7  setosa
R> # Alternate syntax filtering.
R> iris_of_filtered <- subset(iris_of, Petal.Length < 1.5)
R> nrow(iris_of_filtered)[1] 24
R> head(iris_of_filtered, 3)
Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
R> # Using the AND and OR conditions in filtering.
R> # Select all rows with either species = setosa OR species = versicolor
R> # and Petal.Width < 2.0
R> iris_of_filtered <- iris_of[(iris_of$Species == "setosa" |
+                              iris_of$Species == "versicolor") &
+                              iris_of$Petal.Width < 2.0,]
R> nrow(iris_of_filtered)[1] 100
R> head(iris_of, 3)
Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa

関連項目:

- 「データの索引付け」

- sql_like.Rのスクリプト例

データの索引付け

整数ベクターまたは文字列ベクターを使用して、順序付けられたore.frameオブジェクトに索引付けできます。「データのサンプリング」および「データのパーティショニング」で説明する、サンプリングおよびパーティショニングを実行するために索引付けを使用できます。

Oracle R EnterpriseはRの索引付けに類似した機能をサポートしますが、次の違いがあります。

- ore.vectorオブジェクトでは整数索引の作成はサポートされません。

- 負の整数の索引はサポートされません。

- 行の順序は保持されません。

例3-4に、文字の索引付けおよび整数の索引付けを示します。この例では、例2-9のore.frameオブジェクトの順序付けられたSPAM_PKおよび順序付けられていないSPAM_NOPKを使用します。この例は、行に名前でアクセスできること、文字の行名のベクターを指定することで行のセットにアクセスできることも示します。次に、実際の整数値を指定できることを示します。例では、USERID値が1ではなく1001で始まるため、結果は様々な行のセットになります。

例3-4 ore.frameオブジェクトの索引付け

# Index to a specifically named row.
SPAM_PK["2060", 1:4]
# Index to a range of rows by row names.
SPAM_PK[as.character(2060:2064), 1:4]
# Index to a range of rows by integer index.
SPAM_PK[2060:2063, 1:4]

例3-4のリスト

R> # Index to a specifically named row.
R> SPAM_PK["2060", 1:4]
TS USERID make address
2060 2060    380    0       0
R> # Index to a range of rows by row names.
R> SPAM_PK[as.character(2060:2064), 1:4]
TS USERID make address
2060 2060    380    0       0
2061 2061    381    0       0
2062 2062    381    0       0
2063 2063    382    0       0
2064 2064    382    0       0
R> # Index to a range of rows by integer index.
R> SPAM_PK[2060:2063, 1:4]
TS USERID make address
3060 3060    380 0.00    0.00
3061 3061    381 0.00    1.32
3062 3062    381 0.00    2.07
3063 3063    382 0.34    0.00

データの結合

例3-5に示すとおり、merge関数を使用して、データベース表を表すore.frameオブジェクトのデータを結合できます。この例では、2つのdata.frameオブジェクトを作成してそれをマージします。次に、ore.create関数を呼び出して、それぞれのdata.frameオブジェクトにデータベース表を作成します。ore.create関数は、ore.frameオブジェクトを表のプロキシ・オブジェクトとして自動的に作成します。ore.frameオブジェクトには表と同じ名前が付けられます。この例では、ore.frameオブジェクトをマージします。2つのmerge操作の結果の順序は、ore.frameオブジェクトが順序付けられていないために同じでないことに注意してください。

例3-5 2つの表のデータの結合

# Create data.frame objects.
df1 <- data.frame(x1=1:5, y1=letters[1:5])
df2 <- data.frame(x2=5:1, y2=letters[11:15])

# Combine the data.frame objects.
merge (df1, df2, by.x="x1", by.y="x2")

# Create database tables and ore.frame proxy objects to correspond to
# the in-memory R objects df1 and df2.
ore.create(df1, table="DF1_TABLE")
ore.create(df2, table="DF2_TABLE")

# Combine the ore.frame objects.
merge (DF1_TABLE, DF2_TABLE, by.x="x1", by.y="x2")

例3-5のリスト

R> # Create data.frame objects.
R> df1 <- data.frame(x1=1:5, y1=letters[1:5])
R> df2 <- data.frame(x2=5:1, y2=letters[11:15])

R> # Combine the data.frame objects.
R> merge (df1, df2, by.x="x1", by.y="x2")
x1 y1 y2
1  1  a  o
2  2  b  n
3  3  c  m
4  4  d  l
5  5  e  k

R> # Create database tables and ore.frame proxy objects to correspond to
R> # the in-memory R objects df1 and df2.
R> ore.create(df1, table="DF1_TABLE")
R> ore.create(df2, table="DF2_TABLE")

R> # Combine the ore.frame objects.
R> merge (DF1_TABLE, DF2_TABLE, by.x="x1", by.y="x2")
x1 y1 y2
1  5  e  k
2  4  d  l
3  3  c  m
4  2  b  n
5  1  a  o
Warning message:
ORE object has no unique key - using random order

データの集計

例3-6に示すとおり、aggregate関数を使用してデータを集計できます。この例では、irisデータセットをデータベース・メモリーにore.frameオブジェクトのiris_ofとしてプッシュします。length関数を使用して、iris_ofの値をSpecies列で集計します。その後、結果の最初の3行を表示します。

例3-6 データの集計

# Create a temporary database table from the iris data set and get an ore.frame.
iris_of <- ore.push(iris)
aggdata <- aggregate(iris_of$Sepal.Length,
by = list(species = iris_of$Species),
FUN = length)
head(aggdata, 3)

例3-6のリスト

# Create a temporary database table from the iris data set and get an ore.frame.
R> iris_of <- ore.push(iris)
R> aggdata <- aggregate(iris_of$Sepal.Length,
+                      by = list(species = iris_of$Species),
+                      FUN = length)
R> head(aggdata, 3)
species  x
setosa         setosa 50
versicolor versicolor 50
virginica   virginica 50

関連項目:
aggregate.Rのスクリプト例

データの変換

分析用のデータの準備での一般的な手順は、データを再フォーマットするか新しい列を導出してデータセットに追加することによってデータを変換することです。この項の例では、データのフォーマットおよび列の導出のための2つの方法を示します。例3-7では、列のデータをフォーマットするための関数を作成し、例3-8では、transform関数を使用して同じことを行います。例3-9では、transform関数を使用して、列をデータセットに追加します。

例3-7 データのフォーマット

# Create a function for formatting data.
petalCategory_fmt <- function(x) {
ifelse(x > 5, 'LONG',
ifelse(x > 2, 'MEDIUM', 'SMALL'))
}
# Create an ore.frame in database memory with the iris data set.
iris_of <- ore.push(iris)
# Select some rows from iris_of.
iris_of[c(10, 20, 60, 80, 110, 140),]
# Format the data in Petal.Length column.
iris_of$Petal.Length <- petalCategory_fmt(iris_of$Petal.Length)
# Select the same rows from iris_of.

例3-7のリスト

# Create a function for formatting data.
R> petalCategory_fmt <- function(x) {
+    ifelse(x > 5, 'LONG',
+    ifelse(x > 2, 'MEDIUM', 'SMALL'))
+ }
# Create an ore.frame in database memory with the iris data set.
R> iris_of <- ore.push(iris)
# Select some rows from iris_of.
R> iris_of[c(10, 20, 60, 80, 110, 140),]
Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
10           4.9         3.1          1.5         0.1     setosa
20           5.1         3.8          1.5         0.3     setosa
60           5.2         2.7          3.9         1.4 versicolor
80           5.7         2.6          3.5         1.0 versicolor
110          7.2         3.6          6.1         2.5  virginica
140          6.9         3.1          5.4         2.1  virginica
# Format the data in Petal.Length column.
R> iris_of$Petal.Length <- petalCategory_fmt(iris_of$Petal.Length)
# Select the same rows from iris_of.
R> iris_of[c(10, 20, 60, 80, 110, 140),]
Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
10           4.9         3.1        SMALL         0.1     setosa
20           5.1         3.8        SMALL         0.3     setosa
60           5.2         2.7       MEDIUM         1.4 versicolor
80           5.7         2.6       MEDIUM         1.0 versicolor
110          7.2         3.6         LONG         2.5  virginica
140          6.9         3.1         LONG         2.1  virginica

例3-8では、データセットの列にあるデータを再フォーマットするためにtransform関数を使用することを除いて、例3-7と同じことを行います。

例3-8 transform関数の使用方法

# Create an ore.frame in database memory with the iris data set.
iris_of2 <- ore.push(iris)
# Select some rows from iris_of.
iris_of2[c(10, 20, 60, 80, 110, 140),]
iris_of2 <- transform(iris_of2,
Petal.Length = ifelse(Petal.Length > 5, 'LONG',
ifelse(Petal.Length > 2, 'MEDIUM', 'SMALL')))
iris_of2[c(10, 20, 60, 80, 110, 140),]

例3-8のリスト

# Create an ore.frame in database memory with the iris data set.
R> iris_of2 <- ore.push(iris)
# Select some rows from iris_of.
R> iris_of2[c(10, 20, 60, 80, 110, 140),]
Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
10           4.9         3.1          1.5         0.1     setosa
20           5.1         3.8          1.5         0.3     setosa
60           5.2         2.7          3.9         1.4 versicolor
80           5.7         2.6          3.5         1.0 versicolor
110          7.2         3.6          6.1         2.5  virginica
140          6.9         3.1          5.4         2.1  virginica
R> iris_of2 <- transform(iris_of2,
+                  Petal.Length = ifelse(Petal.Length > 5, 'LONG',
+                                 ifelse(Petal.Length > 2, 'MEDIUM', 'SMALL')))
R> iris_of2[c(10, 20, 60, 80, 110, 140),]
Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
10           4.9         3.1        SMALL         0.1     setosa
20           5.1         3.8        SMALL         0.3     setosa
60           5.2         2.7       MEDIUM         1.4 versicolor
80           5.7         2.6       MEDIUM         1.0 versicolor
110          7.2         3.6         LONG         2.5  virginica
140          6.9         3.1         LONG         2.1  virginica

例3-9では、transform関数を使用して派生列をデータセットに追加した後に、追加の列を追加します。

例3-9 派生列の追加

# Set the page width.
options(width = 80)
# Create an ore.frame in database memory with the iris data set.
iris_of <- ore.push(iris)
names(iris_of)
# Add one column derived from another
iris_of <- transform(iris_of, LOG_PL = log(Petal.Length))
names(iris_of)
head(iris_of, 3)
# Add more columns.
iris_of <- transform(iris_of,
SEPALBINS = ifelse(Sepal.Length < 6.0, "A", "B"),
PRODUCTCOLUMN = Petal.Length * Petal.Width,
CONSTANTCOLUMN = 10)
names(iris_of)
# Select some rows of iris_of.
iris_of[c(10, 20, 60, 80, 110, 140),]

例3-9のリスト

R> # Set the page width.
R> options(width = 80)
# Create an ore.frame in database memory with the iris data set.
R> iris_of <- ore.push(iris)
R> names(iris_of)
[1] "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width"  "Species"
R> # Add one column derived from another
R> iris_of <- transform(iris_of, LOG_PL = log(Petal.Length))
R> names(iris_of)
[1] "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width"  "Species"
[6] "LOG_PL"
R> head(iris_of, 3)
Sepal.Length Sepal.Width Petal.Length Petal.Width Species    LOG_PL
1          5.1         3.5          1.4         0.2  setosa 0.3364722
2          4.9         3.0          1.4         0.2  setosa 0.3364722
3          4.7         3.2          1.3         0.2  setosa 0.2623643
R> # Add more columns.
R> iris_of <- transform(iris_of,
SEPALBINS = ifelse(Sepal.Length < 6.0, "A", "B"),
PRODUCTCOLUMN = Petal.Length * Petal.Width,
CONSTANTCOLUMN = 10)
R> names(iris_of)
[1] "Sepal.Length"   "Sepal.Width"    "Petal.Length"   "Petal.Width"
[5] "Species"        "LOG_PL"         "CONSTANTCOLUMN" "SEPALBINS"
[9] "PRODUCTCOLUMN"
R> # Select some rows of iris_of.
R> iris_of[c(10, 20, 60, 80, 110, 140),]
Sepal.Length Sepal.Width Petal.Length Petal.Width    Species    LOG_PL
10           4.9         3.1          1.5         0.1     setosa 0.4054651
20           5.1         3.8          1.5         0.3     setosa 0.4054651
60           5.2         2.7          3.9         1.4 versicolor 1.3609766
80           5.7         2.6          3.5         1.0 versicolor 1.2527630
110          7.2         3.6          6.1         2.5  virginica 1.8082888
140          6.9         3.1          5.4         2.1  virginica 1.6863990
CONSTANTCOLUMN SEPALBINS PRODUCTCOLUMN
10              10         A          0.15
20              10         A          0.45
60              10         A          5.46
80              10         A          3.50
110             10         B         15.25
140             10         B         11.34

関連項目:
derived.Rのスクリプト例

データのサンプリング

サンプリングは統計分析の重要な機能です。通常、データのサイズを減らし、意味のある作業を実行するためにデータをサンプリングします。Rでは、通常、サンプリングするには、データをメモリーにロードする必要があります。ただし、データが非常に大きい場合、それは不可能です。

Oracle R Enterpriseでは、データベースからデータをプルしてサンプリングするかわりに、データベースで直接サンプリングしてそのサンプル部分であるレコードのみをプルできます。データベースでサンプリングすることで、データの移動を最小化するため、より大きなデータセットで作業できます。これは、この機能を可能にする透過層での順序付けフレームワークの整数行の索引付けであることに注意してください。

注意:
サンプリングには、「序付けられたおよび順序付けられていないore.frameオブジェクトの作成」で説明する順序付けられたore.frameオブジェクトを使用する必要があります。

この項の例に、いくつかのサンプリング手法を示します。同様の例は、sampling.Rのスクリプト例にあります。

例3-10に、行をランダムに簡単に選択する方法を示します。この例では、小規模なdata.frameオブジェクトを作成し、それをデータベースにプッシュしてore.frameオブジェクトであるMYDATAを作成します。20行のうちの5行をサンプリングします。Rのsample関数を使用して、MYDATAからサンプルを取得するために使用する索引のランダムなセットを生成します。このサンプル(simpleRandomSample)はore.frameオブジェクトです。

例3-10 簡単なランダム・サンプリング

set.seed(1)
N <- 20
myData <- data.frame(a=1:N,b=letters[1:N])
MYDATA <- ore.push(myData)
head(MYDATA)
sampleSize <- 5
simpleRandomSample <- MYDATA[sample(nrow(MYDATA), sampleSize), , drop=FALSE]
class(simpleRandomSample)
simpleRandomSample

例3-10のリスト

R> set.seed(1)
R> N <- 20
R> myData <- data.frame(a=1:N,b=letters[1:N])
R> MYDATA <- ore.push(myData)
R> head(MYDATA)
a b
1 1 a
2 2 b
3 3 c
4 4 d
5 5 e
6 6 f
R> sampleSize <- 5
R> simpleRandomSample <- MYDATA[sample(nrow(MYDATA), sampleSize), , drop=FALSE]
R> class(simpleRandomSample)
[1] "ore.frame"
attr(,"package")
[1] "OREbase"
R> simpleRandomSample
a b
2   2 b
7   7 g
10 10 j
12 12 l
19 19 s

例3-11に、トレーニング・セットおよびテスト・セットへのデータのランダムなパーティショニングを示します。このデータの分割は通常、新しいデータに対するモデルの効果を評価するために、分類および回帰で行われます。この例では、例3-10で作成したMYDATAオブジェクトを使用します。

例3-11では、テスト・データセットとして使用するための索引のサンプル・セットを生成します。次に、論理ベクターgroupを作成します(索引がサンプルにある場合はTRUE、そうでない場合はFALSE)。次に、行の索引付けを使用して、トレーニング・セット(groupがFALSE)およびテスト・セット(groupがTRUE)を生成します。sample関数の呼出し時に指定したとおり、トレーニング・セットの行数は15でテスト・セットの行数は5であることに注意してください。

例3-11 分割データ・サンプリング

set.seed(1)
sampleSize <- 5
ind <- sample(1:nrow(MYDATA), sampleSize)
group <- as.integer(1:nrow(MYDATA) %in% ind)
MYDATA.train <- MYDATA[group==FALSE,]
dim(MYDATA.train)
MYDATA.test <- MYDATA[group==TRUE,]
dim(MYDATA.test)

例3-11のリスト

R> set.seed(1)
R> sampleSize <- 5
R> ind <- sample(1:nrow(MYDATA), sampleSize)
R> group <- as.integer(1:nrow(MYDATA) %in% ind)
R> MYDATA.train <- MYDATA[group==FALSE,]
dim(MYDATA.train)
[1] 15  2
R> MYDATA.test <- MYDATA[group==TRUE,]
R> dim(MYDATA.test)
[1] 5 2

例3-12に、定期的に行が選択される系統的サンプリングを示します。この例では、seq関数を使用して、2から始まり3ずつ増加する一連の値を作成します。この順序の値の数はMYDATAの行数と同じです。MYDATAオブジェクトは例3-10で作成しています。

例3-12 系統的サンプリング

set.seed(1)
N <- 20
myData <- data.frame(a=1:20,b=letters[1:N])
MYDATA <- ore.push(myData)
head(MYDATA)
start <- 2
by <- 3
systematicSample <- MYDATA[seq(start, nrow(MYDATA), by = by), , drop = FALSE]
systematicSample

例3-12のリスト

R> set.seed(1)
R> N <- 20
R> myData <- data.frame(a=1:20,b=letters[1:N])
R> MYDATA <- ore.push(myData)
R> head(MYDATA)
a b
1 1 a
2 2 b
3 3 c
4 4 d
5 5 e
6 6 f
R> start <- 2
R> by <- 3
R> systematicSample <- MYDATA[seq(start, nrow(MYDATA), by = by), , drop = FALSE]
systematicSample
a b
2   2 b
5   5 e
8   8 h
11 11 k
14 14 n
17 17 q
20 20 t

例3-13に、層別サンプリングを示しますが、ここでは、行は各グループ(特定の列の値によって定義されます)内で選択されます。この例では、各行がグループに割り当てられているデータセットを作成します。関数rnormはランダムの正規値を生成します。引数4は分布の目標平均です。グループに応じてデータを分割し、各パーティションに比例してサンプリングします。最後に、サブセットore.frameオブジェクトのリストを1つのore.frameオブジェクトに行バインドし、結果の値stratifiedSampleを表示します。

例3-13 層別サンプリング

set.seed(1)
N <- 200
myData <- data.frame(a=1:N,b=round(rnorm(N),2),
group=round(rnorm(N,4),0))
MYDATA <- ore.push(myData)
head(MYDATA)
sampleSize <- 10
stratifiedSample <- do.call(rbind,
lapply(split(MYDATA, MYDATA$group),
function(y) {
ny <- nrow(y)
y[sample(ny, sampleSize*ny/N), , drop = FALSE]
}))
stratifiedSample

例3-13のリスト

R> set.seed(1)
R> N <- 200
R> myData <- data.frame(a=1:N,b=round(rnorm(N),2),
+                       group=round(rnorm(N,4),0))
R> MYDATA <- ore.push(myData)
R> head(MYDATA)
a     b group
1 1 -0.63     4
2 2  0.18     6
3 3 -0.84     6
4 4  1.60     4
5 5  0.33     2
6 6 -0.82     6
R> sampleSize <- 10
R> stratifiedSample <- do.call(rbind,
+                              lapply(split(MYDATA, MYDATA$group),
+                                function(y) {
+                                  ny <- nrow(y)
+                                  y[sample(ny, sampleSize*ny/N), , drop = FALSE]
+                             }))
R> stratifiedSample
a     b group
173|173 173  0.46     3
9|9       9  0.58     4
53|53    53  0.34     4
139|139 139 -0.65     4
188|188 188 -0.77     4
78|78    78  0.00     5
137|137 137 -0.30     5

例3-14に、グループ全体がランダムに選択されるクラスタ・サンプリングを示します。この例では、グループに応じてデータを分割してから、グループ内でサンプリングし、1つのore.frameオブジェクトに行バインドします。生成されるサンプルには、6および7の2つのクラスタのデータが含まれます。

例3-14 クラスタ・サンプリング

set.seed(1)
N <- 200
myData <- data.frame(a=1:N,b=round(runif(N),2),
group=round(rnorm(N,4),0))
MYDATA <- ore.push(myData)
head(MYDATA)
sampleSize <- 5
clusterSample <- do.call(rbind,
sample(split(MYDATA, MYDATA$group), 2))
unique(clusterSample$group)

例3-14のリスト

R> set.seed(1)
R> N <- 200
R> myData <- data.frame(a=1:N,b=round(runif(N),2),
+                       group=round(rnorm(N,4),0))
R> MYDATA <- ore.push(myData)
R> head(MYDATA)
a    b group
1 1 0.27     3
2 2 0.37     4
3 3 0.57     3
4 4 0.91     4
5 5 0.20     3
6 6 0.90     6
R> sampleSize <- 5
R> clusterSample <- do.call(rbind,
+                           sample(split(MYDATA, MYDATA$group), 2))
R> unique(clusterSample$group)
[1] 6 7

例3-15に、サンプルとして連続したレコード番号が選択される割当てサンプリングを示します。この例では、head関数を使用してサンプルを選択します。tail関数も使用できます。

例3-15 割当てサンプリング

set.seed(1)
N <- 200
myData <- data.frame(a=1:N,b=round(runif(N),2))
MYDATA <- ore.push(myData)
sampleSize <- 10
quotaSample1 <- head(MYDATA, sampleSize)
quotaSample1

例3-15のリスト

R> set.seed(1)
R> N <- 200
R> myData <- data.frame(a=1:N,b=round(runif(N),2))
R> MYDATA <- ore.push(myData)
R> sampleSize <- 10
R> quotaSample1 <- head(MYDATA, sampleSize)
R> quotaSample1
a    b
1   1 0.15
2   2 0.75
3   3 0.98
4   4 0.97
5   5 0.35
6   6 0.39
7   7 0.95
8   8 0.11
9   9 0.93
10 10 0.35

データのパーティショニング

大規模なデータセットの分析での通常の操作は、データセットをランダムにサブセットにパーティショニングすることです。例3-16に示すとおり、Oracle R Enterpriseの埋込みRの実行を使用することでパーティションを分析できます。この例では、data.frameオブジェクトを記号myDataを付けてローカルのRセッションに作成し、ランダムに生成された値のセットを含むそのオブジェクトに列を追加します。このデータセットをオブジェクトMYDATAとしてデータベース・メモリーにプッシュします。この例では、埋込みRの実行関数ore.groupApplyを呼び出し、パーティション列に基づいてデータをパーティショニングした後に、各パーティションにlm関数を適用します。

例3-16 データのランダムなパーティショニング

N <- 200
k <- 5
myData <- data.frame(a=1:N,b=round(runif(N),2))
myData$partition <- sample(rep(1:k, each = N/k,
length.out = N), replace = TRUE)
MYDATA <- ore.push(myData)
head(MYDATA)
results <- ore.groupApply(MYDATA, MYDATA$partition,
function(y) {lm(b~a,y)}, parallel = TRUE)
length(results)
results[[1]]

例3-16のリスト

R> N <- 200
R> k <- 5
R> myData <- data.frame(a=1:N,b=round(runif(N),2))
R> myData$partition <- sample(rep(1:k, each = N/k,
+                             length.out = N), replace = TRUE)
R> MYDATA <- ore.push(myData)
R> head(MYDATA)
a    b partition
1 1 0.89         2
2 2 0.31         4
3 3 0.39         5
4 4 0.66         3
5 5 0.01         1
6 6 0.12         4
R> results <- ore.groupApply(MYDATA, MYDATA$partition,
+                            function(y) {lm(b~a,y)}, parallel = TRUE)
R> length(results)
[1] 5
R> results[[1]]

Call:
lm(formula = b ~ a, data = y)

Coefficients:
(Intercept)            a
0.388795     0.001015

関連項目:
第6章「Oracle R Enterpriseの埋込みRの実行の使用方法」

時系列データの準備

Oracle R Enterpriseでは、時系列データに対して、データのフィルタ処理、順序付け、変換などの多数のデータの準備操作を実行できます。Oracle R Enterpriseは、表1-1に示すようにRデータ型をSQLデータ型にマップすることで、Oracle R Enterpriseオブジェクトを作成し、データ準備操作をデータベース・メモリーで実行できます。

次の例では、時系列データに対する操作の一部を示します。

例3-17に、統計の集計関数の一部を示します。最初に、データセットに対して、2001年全体に均等に分散された一連の日付をローカル・クライアントに500個生成します。次に、ランダムのdifftimeおよびランダムの正規値のベクターを使用します。その後、ore.push関数を使用してデータのデータベース内版であるMYDATAを作成します。この例では、MYDATAがore.frameオブジェクトであること、およびdatetime列がクラスore.datetimeであることを示すためにclass関数を呼び出します。この例では、生成されたデータの最初の3行を表示します。次に、min、max、range、medianおよびquantileの統計の集計操作をMYDATAのdatetime列で使用します。

例3-17 日時データの集計

N <- 500
mydata <- data.frame(datetime =
seq(as.POSIXct("2001/01/01"),
as.POSIXct("2001/12/31"),
length.out = N),
difftime = as.difftime(runif(N),
units = "mins"),
x = rnorm(N))
MYDATA <- ore.push(mydata)
class(MYDATA)
class(MYDATA$datetime)
head(MYDATA,3)
# statistical aggregations
min(MYDATA$datetime)
max(MYDATA$datetime)
range(MYDATA$datetime)
quantile(MYDATA$datetime,
probs = c(0, 0.05, 0.10))

例3-17のリスト

R> N <- 500
R> mydata <- data.frame(datetime =
+             seq(as.POSIXct("2001/01/01"),
+                 as.POSIXct("2001/12/31"),
+                 length.out = N),
+             difftime = as.difftime(runif(N),
+                              units = "mins"),
+             x = rnorm(N))
R> MYDATA <- ore.push(mydata)
R> class(MYDATA)
[1] "ore.frame"
attr(,"package")
[1] "OREbase"
R> class(MYDATA$datetime)
[1] "ore.datetime"
attr(,"package")
[1] "OREbase"
R> head(MYDATA,3)
datetime       difftime           x
1 2001-01-01 00:00:00 16.436782 secs  0.68439244
2 2001-01-01 17:30:25  8.711562 secs  1.38481435
3 2001-01-02 11:00:50  1.366927 secs -0.00927078

R> # statistical aggregations
R> min(MYDATA$datetime)
[1] "2001-01-01 CST"
R> max(MYDATA$datetime)
[1] "2001-12-31 CST"
R> range(MYDATA$datetime)
[1] "2001-01-01 CST" "2001-12-31 CST"
R> quantile(MYDATA$datetime,
+           probs = c(0, 0.05, 0.10))
0%                        5%                       10%
"2001-01-01 00:00:00 CST" "2001-01-19 04:48:00 CST" "2001-02-06 09:36:00 CST"

例3-18では、例3-17で作成したMYDATAのore.frameのdatetime列を使用して、1日分のdifftimeを追加することで、1日分のずれを作成します。結果はday1Shiftで、この例の表示ではore.datetimeクラスです。この例では、MYDATAのdatetime列およびday1Shiftの最初の3要素を表示します。day1Shiftの最初の要素は2001年1月2日です。

例3-18ではさらに、オーバーロードされたdiff関数を使用して遅れの差を計算します。MYDATAの500日は2001年全体で均等に分散されているため、日付間の差はすべて同じです。

例3-18 日付および時間の計算の使用方法

day1Shift <- MYDATA$datetime + as.difftime(1, units = "days")
class(day1Shift)
head(MYDATA$datetime,3)
head(day1Shift,3)
lag1Diff <- diff(MYDATA$datetime)
class(lag1Diff)
head(lag1Diff,3)

例3-18のリスト

R> day1Shift <- MYDATA$datetime + as.difftime(1, units = "days")
R> class(day1Shift)
[1] "ore.datetime"
attr(,"package")
[1] "OREbase"
R> head(MYDATA$datetime,3)
[1] "2001-01-01 00:00:00 CST" "2001-01-01 17:30:25 CST" "2001-01-02 11:00:50 CST"
R> head(day1Shift,3)
[1] "2001-01-02 00:00:00 CST" "2001-01-02 17:30:25 CST" "2001-01-03 11:00:50 CST"
R> lag1Diff <- diff(MYDATA$datetime)
R> class(lag1Diff)
[1] "ore.difftime"
attr(,"package")
[1] "OREbase"
R> head(lag1Diff,3)
Time differences in secs
[1] 63025.25 63025.25 63025.25

例3-19に、日付および時間の比較を示します。この例では、例3-17で作成したMYDATAのore.frameオブジェクトのdatetime列を使用します。例3-19では、2001年4月1日より前の日付を含むMYDATAの要素を選択します。生成されるisQ1はクラスore.logicalで、最初の3エントリの結果はTRUEです。この例では、isQ1に一致する日付が3月に何日あるかを検出します。次に、論理ベクターを集計して結果(3月には43行)を表示します。この例では次に、その年の12月27日以降の最後の日付に基づいて行をフィルタします。この結果はeoySubsetで、これはore.frameオブジェクトです。この例では、eoySubsetで返された最初の3行を表示します。

例3-19 日付および時間の比較

isQ1 <- MYDATA$datetime < as.Date("2001/04/01")
class(isQ1)
head(isQ1,3)
isMarch <- isQ1 & MYDATA$datetime > as.Date("2001/03/01")
class(isMarch)
head(isMarch,3)
sum(isMarch)
eoySubset <- MYDATA[MYDATA$datetime > as.Date("2001/12/27"), ]
class(eoySubset)
head(eoySubset,3)

例3-19のリスト

R> isQ1 <- MYDATA$datetime < as.Date("2001/04/01")
R> class(isQ1)
[1] "ore.logical"
attr(,"package")
[1] "OREbase"
R> head(isQ1,3)
[1] TRUE TRUE TRUE
R> isMarch <- isQ1 & MYDATA$datetime > as.Date("2001/03/01")
R> class(isMarch)
[1] "ore.logical"
attr(,"package")
[1] "OREbase"
R> head(isMarch,3)
[1] FALSE FALSE FALSE
R> sum(isMarch)
[1] 43
R> eoySubset <- MYDATA[MYDATA$datetime > as.Date("2001/12/27"), ]
R> class(eoySubset)
[1] "ore.frame"
attr(,"package")
[1] "OREbase"
R> head(eoySubset,3)
datetime      difftime          x
495 2001-12-27 08:27:53 55.76474 secs -0.2740492
496 2001-12-28 01:58:18 15.42946 secs -1.4547270
497 2001-12-28 19:28:44 28.62195 secs  0.2929171

Oracle R Enterpriseには、datetimeオブジェクトから年、月、月の日付、時間、分、秒などの様々なコンポーネントの抽出に使用できるアクセッサ関数があります。例3-20に、これらの関数の使用を示します。この例では、例3-17で作成したMYDATAのore.frameオブジェクトのdatetime列を使用します。

例3-20では、datetime列の年要素を取得します。yearに対してunique関数を呼び出すと、列内の唯一の年の値である2001が表示されます。ただし、値の範囲を持つore.mdayなどのオブジェクトの場合は、range関数は月の日付を返します。この結果には、1から31の間の値を持つベクターが含まれています。他のアクセッサ関数で示すように、range関数を呼び出すと、値の範囲が簡潔にレポートされます。

例3-20 日付および時間のアクセッサの使用方法

year <- ore.year(MYDATA$datetime)
unique(year)
month <- ore.month(MYDATA$datetime)
range(month)
dayOfMonth <- ore.mday(MYDATA$datetime)
range(dayOfMonth)
hour <- ore.hour(MYDATA$datetime)
range(hour)
minute <- ore.minute(MYDATA$datetime)
range(minute)
second <- ore.second(MYDATA$datetime)
range(second)

例3-20のリスト

R> year <- ore.year(MYDATA$datetime)
R> unique(year)
[1] 2001
R> month <- ore.month(MYDATA$datetime)
R> range(month)
[1]  1 12
R> dayOfMonth <- ore.mday(MYDATA$datetime)
R> range(dayOfMonth)
[1]  1 31
R> hour <- ore.hour(MYDATA$datetime)
R> range(hour)
[1]  0 23
R> minute <- ore.minute(MYDATA$datetime)
R> range(minute)
[1]  0 59
R> second <- ore.second(MYDATA$datetime)
R> range(second)
[1]  0.00000 59.87976

例3-21では、as.oreサブクラスのオブジェクトを使用して、ore.datetimeデータ型を他のデータ型に強制変換します。この例では、例3-17で作成したMYDATAのore.frameオブジェクトのdatetime列を使用します。この列にはore.datetime値が含まれています。例3-21では、最初にMYDATA$datetime列から日付を抽出します。生成されるdateOnlyオブジェクトには、年、月および日のみを含み時間を含まないore.date値が含まれます。この例では次に、ore.datetime値を、日の名前、年の日数および年の四半期を表すore.character値およびore.integer値を持つオブジェクトに強制変換します。

例3-21 日付および時間のデータ型の強制変換

dateOnly <- as.ore.date(MYDATA$datetime)
class(dateOnly)
head(sort(unique(dateOnly)),3)
nameOfDay <- as.ore.character(MYDATA$datetime, format = "DAY")
class(nameOfDay)
sort(unique(nameOfDay))
dayOfYear <- as.integer(as.character(MYDATA$datetime, format = "DDD"))
class(dayOfYear)
range(dayOfYear)
quarter <- as.integer(as.character(MYDATA$datetime, format = "Q"))
class(quarter)
sort(unique(quarter))

例3-21のリスト

R> dateOnly <- as.ore.date(MYDATA$datetime)
R> class(dateOnly)[1] "ore.date"
attr(,"package")[1] "OREbase"
R> head(sort(unique(dateOnly)),3)
[1] "2001-01-01" "2001-01-02" "2001-01-03"
R> nameOfDay <- as.ore.character(MYDATA$datetime, format = "DAY")
R> class(nameOfDay)
[1] "ore.character"
attr(,"package")
[1] "OREbase"
R> sort(unique(nameOfDay))
[1] "FRIDAY " "MONDAY " "SATURDAY " "SUNDAY " "THURSDAY " "TUESDAY " "WEDNESDAY"
R> dayOfYear <- as.integer(as.character(MYDATA$datetime, format = "DDD"))
R> class(dayOfYear)
[1] "ore.integer"
attr(,"package")
[1] "OREbase"
R> range(dayOfYear)
[1]   1 365
R> quarter <- as.integer(as.character(MYDATA$datetime, format = "Q"))
R> class(quarter)
[1] "ore.integer"
attr(,"package")
[1] "OREbase"
R> sort(unique(quarter))
[1] 1 2 3 4

例3-22では、ウィンドウ関数のore.rollmeanおよびore.rollsdを使用して、ローリング平均およびローリング標準偏差を計算します。この例では、例3-17で作成したMYDATAのore.frameオブジェクトを使用します。この例では、datetime列の値をMYDATAの行名として割り当てることで、MYDATAが順序付けられたore.frameであることを確認します。この例では、5期間のローリング平均およびローリング標準偏差を計算します。次に、statsパッケージでRの時系列機能を使用するために、クライアントにデータをプルします。クライアントにプルするデータを制限するために、例3-19のベクターis.Marchを使用して3月をポイントするデータのみを選択します。この例では、ts関数を使用して時系列オブジェクトを作成し、Arimaモデルを構築し、3点を予測します。

例3-22 ウィンドウ関数の使用方法

row.names(MYDATA) <- MYDATA$datetime
MYDATA$rollmean5 <- ore.rollmean(MYDATA$x, k = 5)
MYDATA$rollsd5 <- ore.rollsd (MYDATA$x, k = 5)
head(MYDATA)
marchData <- ore.pull(MYDATA[isMarch,])
tseries.x <- ts(marchData$x)
arima110.x <- arima(tseries.x, c(1,1,0))
predict(arima110.x, 3)
tseries.rm5 <- ts(marchData$rollmean5)
arima110.rm5 <- arima(tseries.rm5, c(1,1,0))
predict(arima110.rm5, 3)

例3-22のリスト

R> row.names(MYDATA) <- MYDATA$datetime
R> MYDATA$rollmean5 <- ore.rollmean(MYDATA$x, k = 5)
R> MYDATA$rollsd5 <- ore.rollsd (MYDATA$x, k = 5)
R> head(MYDATA)
datetime       difftime
2001-01-01 00:00:00 2001-01-01 00:00:00 39.998460 secs
x   rollmean5   rollsd5
-0.3450421 -0.46650761 0.8057575
datetime       difftime
2001-01-01 17:30:25 2001-01-01 17:30:25  37.75568 secs
x   rollmean5   rollsd5
-1.3261019  0.02877517 1.1891384
datetime       difftime
2001-01-02 11:00:50 2001-01-02 11:00:50  18.44243 secs
x   rollmean5   rollsd5
0.2716211 -0.13224503 1.0909515
datetime       difftime
2001-01-03 04:31:15 2001-01-03 04:31:15 38.594384 secs
x   rollmean5   rollsd5
1.5146235  0.36307913 1.4674456
datetime       difftime
2001-01-03 22:01:41 2001-01-03 22:01:41  2.520976 secs
x   rollmean5   rollsd5
-0.7763258  0.80073340 1.1237925
datetime       difftime
2001-01-04 15:32:06 2001-01-04 15:32:06 56.333281 secs
x   rollmean5   rollsd5
2.1315787  0.90287282 1.0862614
R> marchData <- ore.pull(MYDATA[isMarch,])
R> tseries.x <- ts(marchData$x)
R> arima110.x <- arima(tseries.x, c(1,1,0))
R> predict(arima110.x, 3)
$pred
Time Series:
Start = 44
End = 46
Frequency = 1
[1] 1.4556614 0.6156379 1.1387587

$se
Time Series:
Start = 44
End = 46
Frequency = 1
[1] 1.408117 1.504988 1.850830

R> tseries.rm5 <- ts(marchData$rollmean5)
R> arima110.rm5 <- arima(tseries.rm5, c(1,1,0))
R> predict(arima110.rm5, 3)
$pred
Time Series:
Start = 44
End = 46
Frequency = 1
[1] 0.3240135 0.3240966 0.3240922

$se
Time Series:
Start = 44
End = 46
Frequency = 1
[1] 0.3254551 0.4482886 0.5445763

データの探索

Oracle R Enterpriseには、探索的データ分析を実行できる関数があります。これらの関数を使用して、一般的な統計操作を実行できます。

関数およびその使用について、次の各項で説明します。

- 探索的データ分析関数について

- サンプルのNARROWデータセットについて

- データの相互関連付け

- データのクロス集計

- クロス集計の頻度の分析

- 時系列データでの指数平滑法モデルの構築

- データのランキング

- データのソート

- データの集計

- 数値変数の分布の分析

関連項目:
第4章「Oracle R Enterpriseでのモデルの構築」

探索的データ分析関数について

探索的データ分析用のOracle R Enterpriseの関数は、OREedaパッケージにあります。表3-1に、このパッケージにある関数をリストします。

表3-1 OREedaパッケージの関数

関数

説明

ore.corr

ore.frameによる数値列の相関分析を実行します。

ore.crosstab

オプションの集計、重み付けおよび順序付けオプションで複数の列をサポートすることで、xtabs関数上で展開します。クロス集計の構築はore.freq関数の使用における前提条件です。

ore.esm

順序付けられたore.vectorオブジェクトのデータで指数平滑法モデルを構築します。

ore.freq

ore.crosstab関数からの出力を操作して、表に関連する手法を自動的に判断します。

ore.rank

ore.frameオブジェクトの数値列による値の分散の調査を可能にします。

ore.sort

ore.frameオブジェクトの柔軟なソートを提供します。

ore.summary

柔軟な行集約内のore.frameオブジェクトの記述統計を提供します。

ore.univariate

ore.frameオブジェクトの数値列の分布分析を提供します。ore.summary関数プラス符号順位検定および極値からすべての統計をレポートします。

サンプルのNARROWデータセットについて

探索的データ分析関数の多くの例で、NARROWデータセットを使用します。NARROWは、例3-23に示すとおり、9列および1500行のore.frameです。一部の列は数値で、それ以外の列もあります。

例3-23 NARROWデータ・セット

R> class(NARROW)
R> dim(NARROW)
R> names(NARROW)

例3-23のリスト

R> class(NARROW)
[1] "ore.frame"
attr(,"package")
[1] "OREbase"
R> dim(NARROW)[1] 1500    9
R> names(NARROW)
[1] "ID"             "GENDER"         "AGE"            "MARITAL_STATUS"
[5] "COUNTRY"        "EDUCATION"      "OCCUPATION"     "YRS_RESIDENCE"
[9] "CLASS"

データの相互関連付け

ore.corr関数を使用して相関分析を実行できます。ore.corrを使用すると、次のことを実行できます。

- ore.frameによる数値列のピアソン、スピアマンまたはケンドール相関分析を実行します。

- 制御列を指定することによる部分相関を実行します。

- 相関の前に一部のデータを集計します。

- 結果を後処理して、Rコード・フローに統合します。
ore.corr関数の出力をRのcor関数の出力に適合させることができ、これにより、任意のR関数を使用して出力を後処理したり、出力をグラフィック関数の入力として使用できます。

この関数の引数の詳細は、help(ore.corr)を呼び出してください。

次の例にこれらの操作を示します。ほとんどの例でNARROWデータセットを使用しますが、詳細は、「探索的データ分析関数について」を参照してください。

例3-24に、別の種類の相関統計の指定方法を示します。

例3-24 基本的な相関計算の実行

# Before performing correlations, project out all non-numeric values
# by specifying only the columns that have numeric values.
names(NARROW)
NARROW_NUMS <- NARROW[,c(3,8,9)]
names(NARROW_NUMS)
# Calculate the correlation using the default correlation statistic, Pearson.
x <- ore.corr(NARROW_NUMS,var='AGE,YRS_RESIDENCE,CLASS')
head(x, 3)
# Calculate using Spearman.
x <- ore.corr(NARROW_NUMS,var='AGE,YRS_RESIDENCE,CLASS', stats='spearman')
head(x, 3)
# Calculate using Kendall
x <- ore.corr(NARROW_NUMS,var='AGE,YRS_RESIDENCE,CLASS', stats='kendall')
head(x, 3)

例3-24のリスト

R> # Before performing correlations, project out all non-numeric values
R> # by specifying only the columns that have numeric values.
R> names(NARROW)
[1] "ID" "GENDER" "AGE" "MARITAL_STATUS" "COUNTRY" "EDUCATION" "OCCUPATION"
[8] "YRS_RESIDENCE" "CLASS" "AGEBINS"
R> NARROW_NUMS <- NARROW[,c(3,8,9)]
R> names(NARROW_NUMS)
[1] "AGE" "YRS_RESIDENCE" "CLASS"

R> # Calculate the correlation using the default correlation statistic, Pearson.
R> x <- ore.corr(NARROW_NUMS,var='AGE,YRS_RESIDENCE,CLASS')
R> head(x, 3)
ROW           COL PEARSON_T PEARSON_P PEARSON_DF
1           AGE         CLASS 0.2200960     1e-15       1298
2           AGE YRS_RESIDENCE 0.6568534     0e+00       1098
3 YRS_RESIDENCE         CLASS 0.3561869     0e+00       1298
R> # Calculate using Spearman.
R> x <- ore.corr(NARROW_NUMS,var='AGE,YRS_RESIDENCE,CLASS', stats='spearman')
R> head(x, 3)
ROW           COL SPEARMAN_T SPEARMAN_P SPEARMAN_DF
1           AGE         CLASS  0.2601221      1e-15        1298
2           AGE YRS_RESIDENCE  0.7462684      0e+00        1098
3 YRS_RESIDENCE         CLASS  0.3835252      0e+00        1298
R> # Calculate using Kendall
R> x <- ore.corr(NARROW_NUMS,var='AGE,YRS_RESIDENCE,CLASS', stats='kendall')
R> head(x, 3)
ROW           COL KENDALL_T    KENDALL_P KENDALL_DF
1           AGE         CLASS 0.2147107 4.285594e-31       <NA>
2           AGE YRS_RESIDENCE 0.6332196 0.000000e+00       <NA>
3 YRS_RESIDENCE         CLASS 0.3362078 1.094478e-73       <NA>

例3-25では、irisデータセットをデータベースの一時表にプッシュしますが、これにはプロキシore.frameオブジェクトのiris_ofがあります。種ごとにグループ化された相関マトリクスを作成します。

例3-25 相関マトリクスの作成

iris_of <- ore.push(iris)
x <- ore.corr(iris_of, var = "Sepal.Length, Sepal.Width, Petal.Length",
partial = "Petal.Width", group.by = "Species")
class(x)
head(x)

例3-25のリスト

R> iris_of <- ore.push(iris)
R> x <- ore.corr(iris_of, var = "Sepal.Length, Sepal.Width, Petal.Length",
+                partial = "Petal.Width", group.by = "Species")
R> class(x)
[1] "list"
R> head(x)
$setosa
ROW          COL PART_PEARSON_T PART_PEARSON_P PART_PEARSON_DF
1 Sepal.Length Petal.Length      0.1930601   9.191136e-02              47
2 Sepal.Length  Sepal.Width      0.7255823   1.840300e-09              47
3  Sepal.Width Petal.Length      0.1095503   2.268336e-01              47

$versicolor
ROW          COL PART_PEARSON_T PART_PEARSON_P PART_PEARSON_DF
1 Sepal.Length Petal.Length     0.62696041   7.180100e-07              47
2 Sepal.Length  Sepal.Width     0.26039166   3.538109e-02              47
3  Sepal.Width Petal.Length     0.08269662   2.860704e-01              47

$virginica
ROW          COL PART_PEARSON_T PART_PEARSON_P PART_PEARSON_DF
1 Sepal.Length Petal.Length      0.8515725   4.000000e-15              47
2 Sepal.Length  Sepal.Width      0.3782728   3.681795e-03              47
3  Sepal.Width Petal.Length      0.2854459   2.339940e-02              47

関連項目:
cor.Rのスクリプト例

データのクロス集計

クロス集計は、値からなる2つの表の間の相互依存関係を見つける統計手法です。ore.crosstab関数は、ore.frameのクロス列分析を可能にします。この関数は、Rのtable関数の高性能なバリアントです。

ore.freqを使用して頻度分析を実行する前にore.crosstab関数を使用する必要があります。

ore.crosstab関数呼出しの結果が単一のクロス集計の場合、この関数によってore.frameオブジェクトが返されます。結果が複数のクロス集計の場合は、この関数はore.frameオブジェクトのリストを返します。

この関数の引数の詳細は、help(ore.crosstab)を呼び出してください。

ore.corrの例ではNARROWデータセットを使用しますが、詳細は、「サンプルのNARROWデータセットについて」を参照してください。

最も基本的な使用例は、例3-26に示すとおり、単一列頻度表を作成することです。この例では、GENDERによってグループ化されたNARROW ore.frameをフィルタします。

例3-26 単一列頻度表の作成

ct <- ore.crosstab(~AGE, data=NARROW)
head(ct)

例3-26のリスト

R> ct <- ore.crosstab(~AGE, data=NARROW)
R> head(ct)
AGE ORE$FREQ ORE$STRATA ORE$GROUP
17  17       14          1         1
18  18       16          1         1
19  19       30          1         1
20  20       23          1         1
21  21       22          1         1
22  22       39          1         1

例3-27では、GENDERによってAGEを、CLASSによってAGEを分析します。

例3-27 2つの列の分析

ct <- ore.crosstab(AGE~GENDER+CLASS, data=NARROW)
head(ct)

例3-27のリスト

R> ct <- ore.crosstab(AGE~GENDER+CLASS, data=NARROW)
R> head(ct)
$`AGE~GENDER`
AGE GENDER ORE$FREQ ORE$STRATA ORE$GROUP
17|F  17      F        5          1         1
17|M  17      M        9          1         1
18|F  18      F        6          1         1
18|M  18      M        7          1         1
19|F  19      F       15          1         1
19|M  19      M       13          1         1
# The remaining output is not shown.

行を重み付けするには、例3-28に示すとおり、別の列に基づいたカウントを含めます。この例では、YRS_RESIDENCEの値を使用してAGEおよびGENDERの値に重み付けします。

例3-28 行の重み付け

ct <- ore.crosstab(AGE~GENDER*YRS_RESIDENCE, data=NARROW)
head(ct)

クロス集計表の行の順序付けには、次に示すようないくつかの方法があります。

- 分析対象の列によるデフォルトまたはNAMEの順序付け

- 頻度カウントによるFREQの順序付け

- -NAMEまたは-FREQは、順序を逆転します

- INTERNALは、順序付けをバイパスします

例3-28のリスト

R> ct <- ore.crosstab(AGE~GENDER*YRS_RESIDENCE, data=NARROW)
R> head(ct)
AGE GENDER ORE$FREQ ORE$STRATA ORE$GROUP
17|F  17      F        1          1         1
17|M  17      M        8          1         1
18|F  18      F        4          1         1
18|M  18      M       10          1         1
19|F  19      F       15          1         1
19|M  19      M       17          1         1

例3-29では、頻度カウントによって順序付けした後に、頻度カウントで順序を逆にします。

例3-29 クロス集計データの順序付け

ct <- ore.crosstab(AGE~GENDER|FREQ, data=NARROW)
head(ct)
ct <- ore.crosstab(AGE~GENDER|-FREQ, data=NARROW)
head(ct)

例3-29のリスト

R> ct <- ore.crosstab(AGE~GENDER|FREQ, data=NARROW)
R> head(ct)
AGE GENDER ORE$FREQ ORE$STRATA ORE$GROUP66|F  66      F        1          1         170|F  70      F        1          1         173|M  73      M        1          1         174|M  74      M        1          1         176|F  76      F        1          1         177|F  77      F        1          1         1

R> ct <- ore.crosstab(AGE~GENDER|-FREQ, data=NARROW)
R> head(ct)
AGE GENDER ORE$FREQ ORE$STRATA ORE$GROUP
27|M  27      M       33          1         1
35|M  35      M       28          1         1
41|M  41      M       27          1         1
34|M  34      M       26          1         1
37|M  37      M       26          1         1
28|M  28      M       25          1         1

例3-30に、3つ以上の列の分析を示します。結果は、SQLのGROUPING SETS句の実行に似ています。

例3-30 3つ以上の列の分析

ct <- ore.crosstab(AGE+COUNTRY~GENDER, NARROW)
head(ct)

例3-30のリスト

R> ct <- ore.crosstab(AGE+COUNTRY~GENDER, NARROW)
R> head(ct)
$`AGE~GENDER`
AGE GENDER ORE$FREQ ORE$STRATA ORE$GROUP
17|F  17      F        5          1         1
17|M  17      M        9          1         1
18|F  18      F        6          1         1
18|M  18      M        7          1         1
19|F  19      F       15          1         1
19|M  19      M       13          1         1
# The rest of the output is not shown.
$`COUNTRY~GENDER`
COUNTRY GENDER ORE$FREQ ORE$STRATA ORE$GROUP
Argentina|F                Argentina      F       14          1         1
Argentina|M                Argentina      M       28          1         1
Australia|M                Australia      M        1          1         1
# The rest of the output is not shown.

例3-31に示すように、すべての列の名前を入力するかわりに、列の範囲を指定できます。

例3-31 列の範囲の指定

names(NARROW)
# Because AGE, MARITAL_STATUS and COUNTRY are successive columns,
# you can simply do the following:
ct <- ore.crosstab(AGE-COUNTRY~GENDER, NARROW)
# An equivalent invocation is the following:
ct <- ore.crosstab(AGE+MARITAL_STATUS+COUNTRY~GENDER, NARROW)

例3-31のリスト

R> names(NARROW)
R> names(NARROW)
[1] "ID"             "GENDER"         "AGE"            "MARITAL_STATUS"
[5] "COUNTRY"        "EDUCATION"      "OCCUPATION"     "YRS_RESIDENCE"
[9] "CLASS"
R> # Because AGE, MARITAL_STATUS and COUNTRY are successive columns,
R> # you can simply do the following:
R> ct <- ore.crosstab(AGE-COUNTRY~GENDER, NARROW)
R> # An equivalent invocation is the following:
R> ct <- ore.crosstab(AGE+MARITAL_STATUS+COUNTRY~GENDER, NARROW)

例3-32では、別の列COUNTRYの一意の値ごとに1つのクロス集計表(AGE、GENDER)を作成します。

例3-32 別の列の値ごとに1つのクロス集計表の作成

ct <- ore.crosstab(~AGE/COUNTRY, data=NARROW)
head(ct)

例3-32のリスト

R> ct <- ore.crosstab(~AGE/COUNTRY, data=NARROW)
R> head(ct)
AGE ORE$FREQ ORE$STRATA ORE$GROUP
Argentina|17                 17        1          1         1
Brazil|17                    17        1          1         3
United States of America|17  17       12          1        19
United States of America|18  18       16          1        19
United States of America|19  19       30          1        19
United States of America|20  20       23          1        19

例3-33に示すとおり、これを複数の列に拡張できます。この例では、(COUNTRY、GENDER)の一意の組合せごとに1つの(AGE、EDUCATION)表を作成します。

例3-33 2つの列の値のセットごとに1つのクロス集計表の作成

ct <- ore.crosstab(AGE~EDUCATION/COUNTRY+GENDER, data=NARROW)
head(ct)

例3-33のリスト

R> ct <- ore.crosstab(AGE~EDUCATION/COUNTRY+GENDER, data=NARROW)
R> head(ct)
AGE EDUCATION ORE$FREQ ORE$STRATA ORE$GROUP
United States of America|F|17|10th  17      10th        3          1        33
United States of America|M|17|10th  17      10th        5          1        34
United States of America|M|17|11th  17      11th        1          1        34
Argentina|M|17|HS-grad              17   HS-grad        1          1         2
United States of America|M|18|10th  18      10th        1          1        34
United States of America|F|18|11th  18      11th        2          1        33

前述のクロス集計表はすべて、例3-34に示すとおり、階層化で拡張できます。

例3-34 階層化によるクロス集計の拡張

ct <- ore.crosstab(AGE~GENDER^CLASS, data=NARROW)
head(ct)
R> head(ct)
# The previous function invocation is the same as the following:
ct <- ore.crosstab(AGE~GENDER, NARROW, strata="CLASS")

例3-34のリスト

R> ct <- ore.crosstab(AGE~GENDER^CLASS, data=NARROW)
R> head(ct)
R> head(ct)
AGE GENDER ORE$FREQ ORE$STRATA ORE$GROUP
0|17|F  17      F        5          1         1
0|17|M  17      M        9          1         1
0|18|F  18      F        6          1         1
0|18|M  18      M        7          1         1
0|19|F  19      F       15          1         1
0|19|M  19      M       13          1         1
# The previous function invocation is the same as the following:
ct <- ore.crosstab(AGE~GENDER, NARROW, strata="CLASS")

例3-35では、AGEによってカスタム・ビニングを実行してからGENDERおよびビンのクロス集計を計算します。

例3-35 ビニングおよびその後のクロス集計

NARROW$AGEBINS <- ifelse(NARROW$AGE<20, 1, ifelse(NARROW$AGE<30,2,
ifelse(NARROW$AGE<40,3,4)))
ore.crosstab(GENDER~AGEBINS, NARROW)

例3-35のリスト

R> NARROW$AGEBINS <- ifelse(NARROW$AGE<20, 1, ifelse(NARROW$AGE<30,2,
+                    ifelse(NARROW$AGE<40,3,4)))
R> ore.crosstab(GENDER~AGEBINS, NARROW)
GENDER AGEBINS ORE$FREQ ORE$STRATA ORE$GROUP
F|1      F       1       26          1         1
F|2      F       2      108          1         1
F|3      F       3       86          1         1
F|4      F       4      164          1         1
M|1      M       1       29          1         1
M|2      M       2      177          1         1
M|3      M       3      230          1         1
M|4      M       4      381          1         1

クロス集計の頻度の分析

ore.freq関数は、ore.crosstab関数の出力を分析し、ore.crosstabの結果に関連する手法を自動的に判別します。この手法は、次に示すようなクロス集計表の種類に応じて異なります。

- 2方向のクロス集計表

- クロス集計における列の間の関係を記述する様々な統計

- カイ二乗検定、Cochran-Mantel-Haenzsel統計、属性相関、関連の強固性、リスクの相違、オッズ比および2x2表の相対リスク、トレンドの検定

- N方向のクロス集計表

- N 2方向のクロス集計表

- 階層内または階層にわたる統計

ore.freq関数は、使用可能な場合はOracle DatabaseのSQL関数を使用します。

ore.freq関数は、すべての場合にore.frameを返します。

ore.freqを使用する前に、例3-36に従ってクロス集計を計算する必要があります。

この関数の引数の詳細は、ore.freqを呼び出してください。

例3-36では、irisデータセットをデータベースにプッシュし、ore.frameオブジェクトのiris_ofを取得します。この例ではクロス集計を取得し、そこでore.freq関数を呼び出します。

例3-36 ore.freq関数の使用方法

IRIS <- ore.push(iris)
ct <- ore.crosstab(Species ~ Petal.Length + Sepal.Length, data = IRIS)
ore.freq(ct)

例3-36のリスト

R> IRIS <- ore.push(iris)
R> ct <- ore.crosstab(Species ~ Petal.Length + Sepal.Length, data = IRIS)
R> ore.freq(ct)
$`Species~Petal.Length`
METHOD     FREQ DF       PVALUE              DESCR GROUP
1 PCHISQ 181.4667 84 3.921603e-09 Pearson Chi-Square     1

$`Species~Sepal.Length`
METHOD  FREQ DF      PVALUE              DESCR GROUP
1 PCHISQ 102.6 68 0.004270601 Pearson Chi-Square     1

時系列データでの指数平滑法モデルの構築

ore.esm関数は、順序付けられたore.vectorオブジェクトで、データベース内時系列観測のための単純または二重の指数平滑化モデルを構築します。この関数は、時系列データ(観測が固定された均等な間隔)、またはトランザクション・データ(観測が均等な間隔ではない)で動作します。この関数は、トランザクション・データを指定された時間間隔で集計でき、モデル化フェーズに移る前に指定された方法で欠損値を処理することもできます。

ore.esm関数は、データベース・サーバーで動作している1つ以上のRエンジンのデータを処理します。この関数は、クラスore.esmのオブジェクトを返します。

predictメソッドを使用して、ore.esmによって構築される指数平滑法モデルの時系列を予測します。forecastパッケージをロード済の場合は、forecastメソッドをore.esmオブジェクトで使用できます。適合メソッドを使用して、トレーニングの時系列データセットの適合値を生成できます。

ore.esm関数の引数の詳細は、help(ore.esm)を呼び出してください。

例3-37では、統合時系列データセットに二重指数平滑法モデルを構築します。予測および適合値を生成するために、predict関数およびfitted関数がそれぞれ呼び出されます。図3-1に、観測、適合値および予測を示します。

例3-37 二重指数平滑法モデルの構築

N <- 5000
ts0 <- ore.push(data.frame(ID=1:N,
VAL=seq(1,5,length.out=N)^2+rnorm(N,sd=0.5)))
rownames(ts0) <- ts0$ID
x <- ts0$VAL
esm.mod <- ore.esm(x, model = "double")
esm.predict <- predict(esm.mod, 30)
esm.fitted <- fitted(esm.mod, start=4000, end=5000)
plot(ts0[4000:5000,], pch='.')
lines(ts0[4000:5000, 1], esm.fitted, col="blue")
lines(esm.predict, col="red", lwd=2)

図3-1 esm.modモデルに基づいた適合値および予測値

例3-38では、トランザクション・データセットに基づいて、単純平滑法モデルを構築します。事前処理として、平均を取ることで値を日レベルで集計し、欠損値に以前の集計値を設定して埋めます。このモデルは次に、集計された日次時系列に構築されます。関数predictは、日毎に予測値を生成するために呼び出されます。

例3-38 トランザクション・データを使用した時系列モデルの構築

ts01 <- data.frame(ID=seq(as.POSIXct("2008/6/13"), as.POSIXct("2011/6/16"),
length.out=4000), VAL=rnorm(4000, 10))
ts02 <- data.frame(ID=seq(as.POSIXct("2011/7/19"), as.POSIXct("2012/11/20"),
length.out=1500), VAL=rnorm(1500, 10))
ts03 <- data.frame(ID=seq(as.POSIXct("2012/12/09"), as.POSIXct("2013/9/25"),
length.out=1000), VAL=rnorm(1000, 10))
ts1 = ore.push(rbind(ts01, ts02, ts03))
rownames(ts1) <- ts1$ID
x <- ts1$VAL
esm.mod <- ore.esm(x, "DAY", accumulate = "AVG", model="simple",
setmissing="PREV")
esm.predict <- predict(esm.mod)
esm.predict

例3-38のリスト

R> ts01 <- data.frame(ID=seq(as.POSIXct("2008/6/13"), as.POSIXct("2011/6/16"),
+                      length.out=4000), VAL=rnorm(4000, 10))
R> ts02 <- data.frame(ID=seq(as.POSIXct("2011/7/19"), as.POSIXct("2012/11/20"),
+                     length.out=1500), VAL=rnorm(1500, 10))
R> ts03 <- data.frame(ID=seq(as.POSIXct("2012/12/09"), as.POSIXct("2013/9/25"),
+                     length.out=1000), VAL=rnorm(1000, 10))
R> ts1 = ore.push(rbind(ts01, ts02, ts03))
R> rownames(ts1) <- ts1$ID
R> x <- ts1$VAL
R> esm.mod <- ore.esm(x, "DAY", accumulate = "AVG", model="simple",
+                     setmissing="PREV")
R> esm.predict <- predict(esm.mod)
R> esm.predict
ID      VAL
1  2013-09-26 9.962478
2  2013-09-27 9.962478
3  2013-09-28 9.962478
4  2013-09-29 9.962478
5  2013-09-30 9.962478
6  2013-10-01 9.962478
7  2013-10-02 9.962478
8  2013-10-03 9.962478
9  2013-10-04 9.962478
10 2013-10-05 9.962478
11 2013-10-06 9.962478
12 2013-10-07 9.962478

図3-1では、TTRパッケージの株のデータを使用します。これは、日ごとの株の終値に基づいて二重指数平滑法モデルを構築します。30日間の予測株価および元の観測を図3-2に示します。

例3-39 間隔を指定した二重指数平滑法モデルの構築

library(TTR)
stock <- "orcl"
xts.data <- getYahooData(stock, 20010101, 20131024)
df.data <- data.frame(xts.data)
df.data$date <- index(xts.data)
of.data <- ore.push(df.data[, c("date", "Close")])
rownames(of.data) <- of.data$date
esm.mod <- ore.esm(of.data$Close, "DAY", model = "double")
esm.predict <- predict(esm.mod, 30)
plot(of.data,type="l")
lines(esm.predict,col="red",lwd=4)

図3-2 株価予測

データのランキング

ore.rank関数は、ore.frameの数値列の値の分布を分析します。

ore.rank関数では、次のような便利な機能がサポートされています。

- グループ内のランキング

- ランク・タイルに基づいた、グループへの行のパーティショニング

- 累積パーセンテージおよびパーセンタイルの計算

- 同順位の処理

- ランクからの標準スコアの計算

ore.rank関数の構文は、対応するSQL問合せより単純です。

ore.rank関数は、すべてのインスタンスでore.frameを返します。

次のRスコアリング・メソッドをore.rankとともに使用できます。

- ランクから指数スコアを計算するには、savageを使用します。

- 正規スコアを計算するには、blom、tukeyまたはvw (ファン・デル・ヴェルデン)のいずれかを使用します。

この関数の引数の詳細は、help(ore.rank)を呼び出してください。

次の例では、ore.rankの使用方法を示します。この例では、NARROWデータセットを使用します。

例3-40では、2つの列AGEおよびCLASSをランキングし、派生列としてその結果をレポートしますが、値は、デフォルトの順序(昇順)でランキングされます。

例3-40 2つの列のランキング

x <- ore.rank(data=NARROW, var='AGE=RankOfAge, CLASS=RankOfClass')

例3-41では、2つの列AGEおよびCLASSをランキングします。同順位がある場合、同順位のすべての値に最小値が割り当てられます。

例3-41 ランキングでの同順位の処理

x <- ore.rank(data=NARROW, var='AGE=RankOfAge, CLASS=RankOfClass', ties='low')

例3-42では、2つの列AGEとおよびCLASSをランキングし、COUNTRYに従って生成される値をランキングします。

例3-42 グループ内のランキング

x <- ore.rank(data=NARROW, var='AGE=RankOfAge, CLASS=RankOfClass', group.by='COUNTRY')

例3-43では、2つの列AGEおよびCLASSをランキングし、その列を十分位数(10パーティション)にパーティショニングします。

例3-43 十分位数へのパーティショニング

x <- ore.rank(data=NARROW, var='AGE=RankOfAge, CLASS=RankOfClass',groups=10)

列を異なる数のパーティションにパーティショニングするには、groupsの値を変更します。たとえば、groups=4では、四分位数にパーティショニングされます。

例3-44では、2つの列AGEおよびCLASSをランキングし、両方の列の累積分布関数を見積ります。

例3-44 累積分布関数の見積り

x <- ore.rank(data=NARROW, var='AGE=RankOfAge, CLASS=RankOfClass',nplus1=TRUE)

例3-45では、2つの列AGEおよびCLASSをランキングし、2つの異なる方法でそのランクをスコアリングします。最初のコマンドは、列を百分位数(100グループ)にパーティショニングします。savageスコアリング・メソッドが指数スコアを計算し、blomスコアリングが正規スコアを計算します。

例3-45 ランクのスコアリング

x <- ore.rank(data=NARROW, var='AGE=RankOfAge,            CLASS=RankOfClass', score='savage', groups=100, group.by='COUNTRY')
x <- ore.rank(data=NARROW, var='AGE=RankOfAge, CLASS=RankOfClass', score='blom')

データのソート

ore.sort関数は、by引数で指定した1つ以上の列によるデータ・フレームの柔軟なソートを可能にします。

ore.sort関数は、他のデータ事前処理関数とともに使用できます。ソートの結果を、Rの視覚化への入力に使用できます。

ore.sort関数のソートはOracle Databaseで実行されます。ore.sort関数は、データベースのnls.sortオプションをサポートします。

ore.sort関数は、ore.frameを返します。

この関数の引数の詳細は、help(ore.sort)を呼び出してください。

次のほとんどの例では、NARROWデータセットを使用します。ONTIME_Sデータセットを使用する例もあります。

例3-46では、列AGEおよびGENDERを降順でソートします。

例3-46 降順での列のソート

x=ore.sort(data=NARROW, by='AGE,GENDER', reverse=TRUE)

例3-47では、AGEを降順で、GENDERを昇順でソートします。

例3-47 列ごとに異なる順序でのソート

x=ore.sort(data=NARROW, by='-AGE,GENDER')

例3-48では、AGEを基準にソートし、AGEの一意の値ごとに1行を保持します。

例3-48 ソートおよび一意の値ごとに1行を返す

x=ore.sort(data=NARROW, by='AGE', unique.key=TRUE)

例3-49では、AGEを基準にソートし、重複する行を削除します。

例3-49 重複列の削除

x=ore.sort(data=NARROW, by='AGE', unique.data=TRUE)

例3-50では、AGEを基準にソートし、重複行を削除し、AGEの一意の値ごとに1行を返します。

例3-50 重複列の削除および一意の値ごとに1列を返す

x=ore.sort(data=NARROW, by='AGE', unique.data=TRUE, unique.key = TRUE)

例3-51では、ソートされた出力で相対順序を維持します。

例3-51 出力での相対順序の維持

x=ore.sort(data=NARROW, by='AGE', stable=TRUE)

次の例では、ONTIME_Sエアラインのデータセットを使用します。例3-52では、ONTIME_Sをエアライン名を基準に降順で、出発の遅延を昇順でソートします。

例3-52 2つの列の異なる順序でのソート

sortedOnTime1 <- ore.sort(data=ONTIME_S, by='-UNIQUECARRIER,DEPDELAY')

例3-53では、ONTIME_Sをエアライン名および出発の遅延を基準にソートし、各組合せの1つを選択します(つまり、一意のキーを返します)。

例3-53 2つの列の異なる順序でのソートおよび一意の組合せの生成

sortedOnTime1 <- ore.sort(data=ONTIME_S, by='-UNIQUECARRIER,DEPDELAY',
unique.key=TRUE)

データの集計

ore.summary関数は、記述統計を計算し、柔軟な行の集計とともに、ore.frame内の列の広範な分析をサポートします。

ore.summary関数では、次の統計がサポートされています。

- 平均、最小、最大、モード、欠損値の数、合計、加重和

- 二乗の補正および未補正合計、値の範囲、stddev、stderr、variance

- 母平均が0であるという仮定をテストするためのt検定

- 尖度、歪度、変動係数

- 分位: p1、p5、p10、p25、p50、p75、p90、p95、p99、qrange

- 平均の片側および両側信頼限界: clm、rclm、lclm

- 極値のタグ付け

ore.summary関数は、同じ結果を生成するSQL問合せと比べて比較的単純な構文を提供します。

ore.summary関数は、group.by引数が使用されている場合を除くすべての場合にore.frameを返します。group.by引数が使用されている場合、ore.summaryは、階層ごとにore.frameを1つずつore.frameオブジェクトのリストを返します。

この関数の引数の詳細は、help(ore.summary)を呼び出してください。

例3-54では、列AGEおよびCLASSの平均値、最小値および最大値を計算し、GENDER列をロールアップ(集計)します。

例3-54 デフォルトの統計の計算

ore.summary(NARROW, class='GENDER', var ='AGE,CLASS', order='freq')

例3-55では、AGEの歪度を列Aとして、CLASSのスチューデントのt分布の可能性を列Bとして計算します。

例3-55 歪度およびt-検定の可能性の計算

ore.summary(NARROW, class='GENDER', var='AGE,CLASS', stats='skew(AGE)=A, probt(CLASS)=B')

例3-56では、YRS_RESIDENCEを重みとしてGENDERによって集計されたAGEの重み付けされた合計を計算します(つまりsum(var*weight)を計算します)。

例3-56 重み付け合計の計算

ore.summary(NARROW, class='GENDER', var='AGE', stats='sum=X', weight='YRS_RESIDENCE')

例3-57では、GENDERおよびMARITAL_STATUSでCLASSをグループ化します。

例3-57 2つの列によるグループ化

ore.summary(NARROW, class='GENDER, MARITAL_STATUS', var='CLASS', ways=1)

例3-58では、GENDERおよびMARITAL_STATUSによってすべての適用可能な方法でCLASSをグループ化します。

例3-58 すべての適用可能な方法でのグループ化

ore.summary(NARROW, class='GENDER, MARITAL_STATUS', var='CLASS', ways='nway')

数値変数の分布の分析

ore.univariate関数は、ore.frameの数値変数の分布分析を提供します。

ore.univariate関数では、次の統計が提供されています。

- summary関数によってレポートされるすべての統計

- 符号順位検定、スチューデントのt-検定

- 極値のレポート

ore.univariate関数は、すべての場合に出力としてore.frameを返します。

この関数の引数の詳細は、help(ore.univariate)を呼び出してください。

例3-59では、AGE、YRS_RESIDENCEおよびCLASSのデフォルトの単変量統計を計算します。

例3-59 デフォルトの単変量統計の計算

ore.univariate(NARROW, var="AGE,YRS_RESIDENCE,CLASS")

例3-60では、YRS_RESIDENCEの位置統計を計算します。

例3-60 デフォルトの単変量統計の計算

ore.univariate(NARROW, var="YRS_RESIDENCE", stats="location")

例3-61では、AGEおよびYRS_RESIDENCEの完全な分位統計を計算します。

例3-61 完全な分位統計の計算

ore.univariate(NARROW, var="AGE,YRS_RESIDENCE",stats="quantiles")

クライアントでのサード・パーティのパッケージの使用方法

Oracle R Enterpriseでは、Comprehensive R Archive Network (CRAN)のオープン・ソースのRパッケージまたは他のサード・パーティのRパッケージの関数を使用する場合、通常は、埋込みRの実行のコンテキストで行います。埋込みRの実行を使用すると、データベース・サーバー上の多量である可能性の高いRAMを利用できます。

ただし、Oracle Database表のデータに対してローカルのRセッションでサード・パーティのパッケージを使用する場合は、ore.pull関数を使用して、データをore.frameオブジェクトからローカル・セッションにdata.frameオブジェクトとして取得する必要があります。これは、DBAの協力なしにデータベースからデータを抽出できることを除いて、オープン・ソースRを使用する場合と同様です。

データベース表からローカルのdata.frameにデータをプルする場合、ローカル・マシンのメモリーに適合するデータ量に使用が制限されます。ローカル・マシンでは、埋込みRの実行で提供される利点を利用できません。

サード・パーティのパッケージを使用するには、システムにインストールして、Rセッションでロードする必要があります。例3-62に、install.packages関数を使用したCRANパッケージのダウンロードおよびインストール、さらにRセッションへのロードを示します。

例3-62 クライアントへのサード・パーティのパッケージのロード

install.packages("arules")
library("arules")

CRANパッケージの使用例については、例4-7「ore.odmAssocRules関数の使用方法」を参照してください。

関連項目:

- 「埋込みRの実行で使用するためのサード・パーティのパッケージのインストール」

- http://www.r-bloggers.com/installing-r-packages/

- 『Oracle R Enterpriseインストレーションおよび管理ガイド』

4 Oracle R Enterpriseでのモデルの構築

Oracle R Enterpriseには、回帰モデル、ニューラル・ネットワーク・モデルおよびOracle Data Miningアルゴリズムに基づいたモデルを構築するための関数が用意されています。

この章では、次の項目について説明します。

- Oracle R Enterpriseモデルの構築

- Oracle Data Miningモデルの構築

Oracle R Enterpriseモデルの構築

Oracle R EnterpriseのパッケージOREmodelsには、ore.frameオブジェクトを使用して拡張分析データ・モデルの作成に使用できる関数(次の各項で説明します)が含まれています。

- OREmodels関数について

- サンプルのlongleyデータセットについて

- 線形回帰モデルの構築

- 一般化線形モデルの構築

- ニューラル・ネットワーク・モデルの構築

OREmodels関数について

OREmodelsパッケージには、ore.frameオブジェクトを使用して拡張分析データ・モデルの構築に使用できる関数が含まれています。OREmodelsの関数を次に示します。

表4-1 OREmodelsパッケージの関数

関数

説明

ore.glm

ore.frame内のデータに対して一般化線形モデルを適合および使用します。

ore.lm

ore.frame内のデータに対して線形回帰モデルを適合します。

ore.neural

ore.frame内のデータに対してニューラル・ネットワーク・モデルを適合します。

ore.stepwise

ore.frame内のデータに対してステップワイズ線形回帰モデルを適合します。

注意:
Rの用語では、「モデルを適合する」という表現は、多くの場合「モデルを構築する」と同じ意味で使用されます。このドキュメントおよびOracle R Enterpriseの関数のオンライン・ヘルプでは、この表現は同じ意味で使用されます。

ore.glm、ore.lmおよびore.stepwiseの関数には次の利点があります。

- アルゴリズムはアウトオブコアQR Factorizationを使用した正確な解決方法を提供します。QR Factorizationは、行列を直交行列と三角行列に分解します。
QRは、困難とされるランクのない適合モデルに使用されるアルゴリズムです。

- メモリーに収まらないデータ、つまりアウトオブコアのデータを処理できます。QRはマトリクスを、メモリーに収めるものとディスクに保存するものの、2つに分解します。
ore.glm、ore.lmおよびore.stepwiseの各関数は、10億行を超えるデータセットを解決できます。

- ore.stepwise関数によって、前方、後方およびステップワイズによるモデル選択の手法を高速に実装できます。

ore.neural関数には次の利点があります。

- ニューラル・ネットワークのスケーラビリティの高い実装であり、10億行のデータセット上のモデルであってもわずか数分で構築できます。ore.neural関数は、小中規模のデータセットに対してはメモリー内、大規模入力に対しては分散(アウトオブコア)の2つのモードで実行できます。

- ユーザーは、活性化関数をニューロン上で層ごとに指定でき、ore.neuralは異なる15の活性化関数をサポートします。

- ユーザーは、0(ゼロ)を含む任意の数の非表示層からなるニューラル・ネットワーク・トポロジを指定できます。

サンプルのlongleyデータセットについて

ほとんどの線形回帰およびore.neuralの例では、Rによって提供されるlongleyデータセットを使用します。これはマクロ経済データセットで、共線回帰の既知の例を提供し、16年にわたり毎年観察された7つの経済変数で構成されます。

例4-1では、longleyデータセットを一時データベース表にプッシュしますが、これにはプロキシore.frameオブジェクトのore.frameがあり、longley_ofの最初の6行を表示します。

例4-1 longleyデータセットの値の表示

longley_of <- ore.push(longley)
head(longley_of)

例4-1のリスト

R> longley_of <- ore.push(longley)
R> dim(longley_of)[1] 16  7
R> head(longley_of)
GNP.deflator     GNP Unemployed Armed.Forces Population Year Employed
1947         83.0 234.289      235.6        159.0    107.608 1947   60.323
1948         88.5 259.426      232.5        145.6    108.632 1948   61.122
1949         88.2 258.054      368.2        161.6    109.773 1949   60.171
1950         89.5 284.599      335.1        165.0    110.929 1950   61.187
1951         96.2 328.975      209.9        309.9    112.075 1951   63.221
1952         98.1 346.999      193.2        359.4    113.270 1952   63.639

線形回帰モデルの構築

ore.lm関数およびore.stepwise関数は、最小二乗回帰およびステップワイズ最小二乗回帰をそれぞれore.frameオブジェクトに表されたデータで実行します。モデル適合は、埋込みRマップ/リデュース処理を使用して生成されますが、このときマップ処理によって、評価される係数の数に応じてQR分解またはマトリクスのクロス積のいずれかが作成されます。基礎となるモデル・マトリクスは、モデルのスパーシティに応じてmodel.matrixオブジェクトまたはsparse.model.matrixオブジェクトのいずれかを使用して作成されます。モデルの係数が推定されると、データの別のパスが実行されて、モデル水準統計が推定されます。

前方、後方またはステップワイズ検索が実行されるとき、XtXおよびXtyマトリクスがサブセット化され、XtXサブセット・マトリクスのコレスキー分解を使用して生成された係数推定に基づくF検定のp値が生成されます。

モデルに共線的な項がある場合、関数ore.lmおよびore.stepwiseは一連の共線的な項に対する係数値を推定しません。ore.stepwiseでは、共線的な項セットは、手順全体から除外されます。

ore.lmおよびore.stepwiseの詳細は、help(ore.lm)を呼び出してください。

例4-2では、longleyデータセットを一時データベース表にプッシュしますが、これにはプロキシore.frameオブジェクトのlongley_ofが含まれています。この例では、ore.lmを使用して線形回帰モデルを構築します。

例4-2 ore.lmの使用方法

longley_of <- ore.push(longley)
# Fit full model
oreFit1 <- ore.lm(Employed ~ ., data = longley_of)
class(oreFit1)
summary(oreFit1)

例4-2のリスト

R> longley_of <- ore.push(longley)
R> # Fit full model
R>  oreFit1 <- ore.lm(Employed ~ ., data = longley_of)
R> class(oreFit1)
[1] "ore.lm"    "ore.model" "lm"
R> summary(oreFit1)

Call:
ore.lm(formula = Employed ~ ., data = longley_of)

Residuals:
Min       1Q   Median       3Q      Max
-0.41011 -0.15767 -0.02816  0.10155  0.45539

Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept)  -3.482e+03  8.904e+02  -3.911 0.003560 **
GNP.deflator  1.506e-02  8.492e-02   0.177 0.863141
GNP          -3.582e-02  3.349e-02  -1.070 0.312681
Unemployed   -2.020e-02  4.884e-03  -4.136 0.002535 **
Armed.Forces -1.033e-02  2.143e-03  -4.822 0.000944 ***
Population   -5.110e-02  2.261e-01  -0.226 0.826212
Year          1.829e+00  4.555e-01   4.016 0.003037 **
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

Residual standard error: 0.3049 on 9 degrees of freedom
Multiple R-squared:  0.9955,    Adjusted R-squared:  0.9925
F-statistic: 330.3 on 6 and 9 DF,  p-value: 4.984e-10

例4-3では、longleyデータセットを一時データベース表にプッシュしますが、これにはプロキシore.frameオブジェクトのlongley_ofが含まれています。この例では、ore.stepwise関数を使用して線形回帰モデルを構築します。

例4-3 ore.stepwise関数の使用方法

longley_of <- ore.push(longley)
# Two stepwise alternatives
oreStep1 <-
ore.stepwise(Employed ~ .^2, data = longley_of, add.p = 0.1, drop.p = 0.1)
oreStep2 <-
step(ore.lm(Employed ~ 1, data = longley_of),
scope = terms(Employed ~ .^2, data = longley_of))

例4-3のリスト

R> longley_of <- ore.push(longley)
R> # Two stepwise alternatives
R> oreStep1 <-
+   ore.stepwise(Employed ~ .^2, data = longley_of, add.p = 0.1, drop.p = 0.1)
R> oreStep2 <-
+   step(ore.lm(Employed ~ 1, data = longley_of),
+               scope = terms(Employed ~ .^2, data = longley_of))
Start:  AIC=41.17
Employed ~ 1

Df Sum of Sq     RSS     AIC
+ GNP           1   178.973   6.036 -11.597
+ Year          1   174.552  10.457  -2.806
+ GNP.deflator  1   174.397  10.611  -2.571
+ Population    1   170.643  14.366   2.276
+ Unemployed    1    46.716 138.293  38.509
+ Armed.Forces  1    38.691 146.318  39.411
<none>                      185.009  41.165

Step:  AIC=-11.6
Employed ~ GNP

Df Sum of Sq     RSS     AIC
+ Unemployed    1     2.457   3.579 -17.960
+ Population    1     2.162   3.874 -16.691
+ Year          1     1.125   4.911 -12.898
<none>                        6.036 -11.597
+ GNP.deflator  1     0.212   5.824 -10.169
+ Armed.Forces  1     0.077   5.959  -9.802
- GNP           1   178.973 185.009  41.165
... The rest of the output is not shown.

一般化線形モデルの構築

ore.glm関数は、ore.frameオブジェクト内のデータに対して一般化線形モデルを適合します。この関数は、Fisherスコアリングの繰返し加重最小二乗(IRLS)アルゴリズムを使用します。

適切ではない係数推定の選択を防ぐ必要がある従来の手順のかわりに、ore.glmは行検索を使用して、繰返しごとに新しい係数推定を選択し、式(1 - alpha) * old + alpha * suggestedを使用して現在の係数推定から開始し、Fisherスコアリングで提案される推定に移動します(ここでalphaは[0, 2]です)。interp制御引数がTRUEの場合、逸脱度は3次スプライン補間によって概算されます。FALSEの場合、逸脱度はフォローアップ・データ・スキャンを使用して計算されます。

各繰返しは、2つまたは3つの埋込みRマップ/リデュース操作で構成されますが、それは、IRLS操作、初期行検索操作およびinterp = FALSEの場合は、オプションのフォローアップ行検索操作です。ore.lmを使用すると、IRLSマップ操作によって、QR分解(update = "qr"の場合)、クロス積(model.matrixのupdate = "crossprod"の場合)またはsparse.model.matrix (引数sparse = TRUEの場合)が作成され、IRLSリデュース操作ブロックは、それらのQR分解またはクロス積行列を更新します。アルゴリズムが収束するか、最大繰返し数に到達したら、最後の埋込みRマップ/リデュース操作が使用され、完全なモデル水準統計が生成されます。

ore.glm関数は、ore.glmオブジェクトを返します。

ore.glm関数の引数の詳細は、help(ore.glm)を呼び出してください。

例4-4では、rpartパッケージをロードしてから、kyphosisデータセットをプロキシore.frameオブジェクトのKYPHOSISが含まれている一時データベース表にプッシュします。この例では、ore.glm関数およびglm関数を使用して一般線形モデルをそれぞれ構築し、このモデルでsummary関数を呼び出します。

例4-4 ore.glm関数の使用方法

# Load the rpart library to get the kyphosis and solder data sets.
library(rpart)
# Logistic regression
KYPHOSIS <- ore.push(kyphosis)
kyphFit1 <- ore.glm(Kyphosis ~ ., data = KYPHOSIS, family = binomial())
kyphFit2 <- glm(Kyphosis ~ ., data = kyphosis, family = binomial())
summary(kyphFit1)
summary(kyphFit2)

例4-4のリスト

R> # Load the rpart library to get the kyphosis and solder data sets.
R> library(rpart)

R> # Logistic regression
R> KYPHOSIS <- ore.push(kyphosis)
R> kyphFit1 <- ore.glm(Kyphosis ~ ., data = KYPHOSIS, family = binomial())
R> kyphFit2 <- glm(Kyphosis ~ ., data = kyphosis, family = binomial())
R> summary(kyphFit1)

Call:
ore.glm(formula = Kyphosis ~ ., data = KYPHOSIS, family = binomial())

Deviance Residuals:
Min       1Q   Median       3Q      Max
-2.3124  -0.5484  -0.3632  -0.1659   2.1613

Coefficients:
Estimate Std. Error z value Pr(>|z|)
(Intercept) -2.036934   1.449622  -1.405  0.15998
Age          0.010930   0.006447   1.696  0.08997 .
Number       0.410601   0.224870   1.826  0.06786 .
Start       -0.206510   0.067700  -3.050  0.00229 **
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

(Dispersion parameter for binomial family taken to be 1)

Null deviance: 83.234  on 80  degrees of freedom
Residual deviance: 61.380  on 77  degrees of freedom
AIC: 69.38

Number of Fisher Scoring iterations: 4

R> summary(kyphFit2)

Call:
glm(formula = Kyphosis ~ ., family = binomial(), data = kyphosis)

Deviance Residuals:
Min       1Q   Median       3Q      Max
-2.3124  -0.5484  -0.3632  -0.1659   2.1613

Coefficients:
Estimate Std. Error z value Pr(>|z|)
(Intercept) -2.036934   1.449575  -1.405  0.15996
Age          0.010930   0.006446   1.696  0.08996 .
Number       0.410601   0.224861   1.826  0.06785 .
Start       -0.206510   0.067699  -3.050  0.00229 **
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

(Dispersion parameter for binomial family taken to be 1)

Null deviance: 83.234  on 80  degrees of freedom
Residual deviance: 61.380  on 77  degrees of freedom
AIC: 69.38

Number of Fisher Scoring iterations: 5

# Poisson regression
R> SOLDER <- ore.push(solder)
R> solFit1 <- ore.glm(skips ~ ., data = SOLDER, family = poisson())
R> solFit2 <- glm(skips ~ ., data = solder, family = poisson())
R> summary(solFit1)

Call:
ore.glm(formula = skips ~ ., data = SOLDER, family = poisson())

Deviance Residuals:
Min       1Q   Median       3Q      Max
-3.4105  -1.0897  -0.4408   0.6406   3.7927

Coefficients:
Estimate Std. Error z value Pr(>|z|)
(Intercept) -1.25506    0.10069 -12.465  < 2e-16 ***
OpeningM     0.25851    0.06656   3.884 0.000103 ***
OpeningS     1.89349    0.05363  35.305  < 2e-16 ***
SolderThin   1.09973    0.03864  28.465  < 2e-16 ***
MaskA3       0.42819    0.07547   5.674 1.40e-08 ***
MaskB3       1.20225    0.06697  17.953  < 2e-16 ***
MaskB6       1.86648    0.06310  29.580  < 2e-16 ***
PadTypeD6   -0.36865    0.07138  -5.164 2.41e-07 ***
PadTypeD7   -0.09844    0.06620  -1.487 0.137001
PadTypeL4    0.26236    0.06071   4.321 1.55e-05 ***
PadTypeL6   -0.66845    0.07841  -8.525  < 2e-16 ***
PadTypeL7   -0.49021    0.07406  -6.619 3.61e-11 ***
PadTypeL8   -0.27115    0.06939  -3.907 9.33e-05 ***
PadTypeL9   -0.63645    0.07759  -8.203 2.35e-16 ***
PadTypeW4   -0.11000    0.06640  -1.657 0.097591 .
PadTypeW9   -1.43759    0.10419 -13.798  < 2e-16 ***
Panel        0.11818    0.02056   5.749 8.97e-09 ***
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

(Dispersion parameter for poisson family taken to be 1)

Null deviance: 6855.7  on 719  degrees of freedom
Residual deviance: 1165.4  on 703  degrees of freedom
AIC: 2781.6

Number of Fisher Scoring iterations: 4

ニューラル・ネットワーク・モデルの構築

ニューラル・ネットワーク・モデルを使用すると、入力と出力との間の複雑な非リニアの関係を取得すること、つまりデータのパターンを見つけることができます。ore.neural関数は、ore.frameのデータに対して回帰用のフィードフォワードニューラル・ネットワーク・モデルを構築します。これは、ノード数を指定可能な複数の非表示層をサポートします。各層には、複数の活性化関数のいずれかを設定できます。

出力層は、単一の数値カテゴリ・ターゲットまたはバイナリのカテゴリ・ターゲットです。出力層には、任意の活性化関数を設定できます。この層には、デフォルトで線形活性化関数があります。

ore.neuralの出力は、タイプore.neuralのオブジェクトになります。

ore.neural関数を使用したモデル化は、センサー・データなどのノイズ・データおよび複合データに適しています。そのようなデータに発生する可能性のある問題は次のとおりです。

- ピクセル値など、(数値)予測子が多い可能性がある

- ターゲットが離散値、実数値またはそのような値のベクターである可能性がある

- トレーニング・データに(ノイズに対して堅牢な)エラーが含まれている可能性がある

- スコアリングが高速

- モデルの透過性が不要なため、モデルの解釈が困難

ニューラル・ネットワーク・モデリングの一般的な手順は次のとおりです。

1. アーキテクチャの指定

2. データの準備

3. モデルの構築

4. 停止条件(反復、許容範囲内の検証セットでのエラー)の指定

5. モデルの統計結果の表示

6. モデルの改善

ore.neural関数に対する引数の詳細は、help(ore.neural)を呼び出してください。

例4-5では、デフォルト値(hidden sizeを1など)でニューラル・ネットワークを構築します。この例では、longleyデータセットのサブセットをデータベース・メモリーのore.frameオブジェクトに、オブジェクトtrainDataとしてプッシュします。次に、longleyの別のサブセットをオブジェクトtestDataとしてデータベースにプッシュします。この例では、trainDataを使用してニューラル・ネットワーク・モデルを構築し、testDataを使用して結果を予測します。

例4-5 ニューラル・ネットワーク・モデルの構築

trainData <- ore.push(longley[1:11, ])
testData <- ore.push(longley[12:16, ])
fit <- ore.neural('Employed ~ GNP + Population + Year', data = trainData)
ans <- predict(fit, newdata = testData)
ans

例4-5のリスト

R> trainData <- ore.push(longley[1:11, ])
R> testData <- ore.push(longley[12:16, ])
R> fit <- ore.neural('Employed ~ GNP + Population + Year', data = trainData)
R> ans <- predict(fit, newdata = testData)
R> ans
pred_Employed
1      67.97452
2      69.50893
3      70.28098
4      70.86127
5      72.31066
Warning message:
ORE object has no unique key - using random order

例4-6では、irisデータセットを一時データベース表にプッシュしますが、これにはプロキシore.frameオブジェクトのIRISが含まれています。この例では、ore.neural関数を使用してニューラル・ネットワーク・モデルを構築し、層ごとに異なる活性化関数を指定します。

例4-6 ore.neuralの使用方法および活性化の指定

IRIS <- ore.push(iris)
fit <- ore.neural(Petal.Length ~ Petal.Width + Sepal.Length,
data = IRIS,
sparse = FALSE,
hiddenSizes = c(20, 5),
activations = c("bSigmoid", "tanh", "linear"))
ans <- predict(fit, newdata = IRIS,
supplemental.cols = c("Petal.Length"))
options(ore.warn.order = FALSE)
head(ans, 3)
summary(ans)

例4-6のリスト

R> IRIS <- ore.push(iris)
R> fit <- ore.neural(Petal.Length ~ Petal.Width + Sepal.Length,
+                   data = IRIS,
+                   sparse = FALSE,
+                   hiddenSizes = c(20, 5),
+                   activations = c("bSigmoid", "tanh", "linear"))
R>
R> ans <- predict(fit, newdata = IRIS,
+                supplemental.cols = c("Petal.Length"))
R> options(ore.warn.order = FALSE)
R> head(ans, 3)
Petal.Length pred_Petal.Length
1          1.4          1.416466
2          1.4          1.363385
3          1.3          1.310709
R> summary(ans)
Petal.Length   pred_Petal.Length
Min.   :1.000   Min.   :1.080
1st Qu.:1.600   1st Qu.:1.568
Median :4.350   Median :4.346
Mean   :3.758   Mean   :3.742
3rd Qu.:5.100   3rd Qu.:5.224
Max.   :6.900   Max.   :6.300

Oracle Data Miningモデルの構築

この項では、Oracle R EnterpriseのOREdmパッケージを使用したRでのOracle Data Miningモデルの構築について説明します。この項の内容は次のとおりです。

- Oracle R Enterpriseを使用したOracle Data Miningモデルの構築について

- 相関ルール・モデルの構築

- 属性評価モデルの構築

- ディシジョン・ツリー・モデルの構築

- 一般化線形モデルの構築

- k-Meansモデルの構築

- Naive Bayesモデルの構築

- 直交パーティショニング・クラスタ・モデルの構築

- Non-Negative Matrix Factorizationモデルの構築

- サポート・ベクター・マシン・モデルの構築

関連項目:
『Oracle Data Mining概要』

Oracle R Enterpriseを使用したOracle Data Miningモデルの構築について

Oracle Data Miningでは、表、ビュー、スター・スキーマ、トランザクション・データおよび非構造化データのマイニングが可能です。OREdm関数は、対応する予測分析関数およびデータ・マイニング関数に、一般的なRの使用法に適合した引数を使用するRインタフェースを提供します。

この項の内容は次のとおりです。

- Oracle R EnterpriseでサポートされるOracle Data Miningモデル

- Oracle R Enterpriseの関数で構築されるOracle Data Miningモデルについて

Oracle R EnterpriseでサポートされるOracle Data Miningモデル

OREdmパッケージの関数は、Oracle Databaseのデータベース内データ・マイニング機能へのアクセスを提供します。これらの関数を使用して、データベースにデータ・マイニング・モデルを構築します。

表4-2に、Oracle Data Miningモデル構築するOracle R Enterpriseの関数および対応するOracle Data Miningのアルゴリズムおよび関数をリストします。

表4-2 Oracle R Enterpriseのデータ・マイニング・モデルの関数

Oracle R Enterpriseの関数

Oracle Data Miningのアルゴリズム

Oracle Data Miningの関数

ore.odmAI

最小記述長

分類または回帰の属性評価

ore.odmAssocRules

Apriori

相関ルール

ore.odmDT

ディシジョン・ツリー

分類

ore.odmGLM

一般化線形モデル

分類および回帰

ore.odmKMeans

k-Means

クラスタリング

ore.odmNB

Naive Bayes

分類

ore.odmNMF

Non-Negative Matrix Factorization

特徴抽出

ore.odmOC

直交パーティショニング・クラスタ(O-Cluster)

クラスタリング

ore.odmSVM

サポート・ベクター・マシン

分類および回帰

Oracle R Enterpriseの関数で構築されるOracle Data Miningモデルについて

各OREdmのRモデル・オブジェクトで、スロットname (またはfit.name)は、OREdm関数で生成された基礎となるOracle Data Miningモデルの名前です。Rモデルが存在している場合は、Oracle Data Miningのモデル名を使用して、次のような他のインタフェースを介してOracle Data Miningモデルにアクセスできます。

- Oracle Data Miner

- SQLインタフェース(SQL*Plus、SQL Developerなど)
具体的には、このモデルはOracle Data MiningのSQL予測機能とともに使用できます。

Oracle Data Minerを使用して、次のことを実行できます。

- 利用可能なモデルのリストを表示する

- モデル・ビューアを使用してモデルの詳細を調べる

- 変換されたデータを適切にスコアリングする

注意:
Rの領域で実行される変換は、Oracle Data MinerまたはSQLスコアリングには引き継がれません。

さらに、SQLを使用して、モデルの詳細を調べるため、または変換されたデータを適切にスコアリングするためのモデルのリストも取得できます。

OREdm関数を使用して構築されたモデルは一時オブジェクトであるため、Oracle R Enterpriseデータストアに明示的に保存されないかぎり、Rセッション終了後は保持されません。一方、Data MinerまたはSQLを使用して構築されたOracle Data Miningモデルは、明示的に削除されるまで存在します。

モデル・オブジェクトは、「データベースでのRオブジェクトの保存および管理」で説明するように保存または保持できます。OREdmで生成されたモデル・オブジェクトを保存すると、このオブジェクトはRセッション全体で存在でき、対応するOracle Data Miningを所定の場所に保持できます。OREdmモデルが存在する間、これをエクスポートおよびインポートでき、その後、Oracle R Enterprise Rオブジェクトの存在から切り離して使用できます。

相関ルール・モデルの構築

ore.odmAssocRules関数は、Aprioriアルゴリズムを実装することで、高頻度アイテム・セットを検索して相関モデルを生成します。これによって、マーケット・バスケット分析のような場合の大量のトランザクション・データにおいて、アイテムの同時発生が検出されます。相関ルールは、トランザクション・レコードで一連のアイテムが出現すれば、もう1つの一連のアイテムが存在するというデータのパターンを特定します。ルールの形成に使用されるアイテムのグループは、発生(ルールの支持度)する頻度および後件が前件(ルールの信頼度)に従う回数に応じて、最小しきい値を渡す必要があります。相関モデルは、ユーザー指定のしきい値よりも大きい支持度および信頼度を備えるすべてのルールを生成します。Aprioriアルゴリズムは効率的で、トランザクション数、アイテム数および生成されるアイテム・セットおよびルールの数が有効に測定されます。

formulaの仕様にはform ~ termsがあり、ここでtermsは分析に含まれる一連の列名です。複数の列名は列名の間に+を使用することで指定されます。~ .は、データのすべての列をモデル構築に使用する場合に使用します。列を除外するには、除外する各列名の前に-を使用します。関数は変換を確認するためにtermsの項目に適用できます。

ore.odmAssocRules関数は、次の形式のデータを受け入れます。

- トランザクション・データ

- アイテムIDおよびアイテム値を使用した複数レコードのケース・データ

- リレーショナル・データ

データの形式の指定の例および関数の引数の詳細は、help(ore.odmAssocRules)を呼び出してください。

関数rulesは、クラスore.rules (一連の相関ルールを指定します)のオブジェクトを返します。ore.pullを使用して、ore.rulesオブジェクトをローカルのRセッションのメモリーにプルできます。ローカルのメモリー内オブジェクトは、arulesパッケージで定義されているクラスrulesのものです。help(ore.rules)を参照してください。

関数itemsetsは、クラスore.itemsets (一連のアイテムセットを指定します)のオブジェクトを返します。ore.pullを使用して、ore.itemsetsオブジェクトをローカルのRセッションのメモリーにプルできます。ローカルのメモリー内オブジェクトは、arulesパッケージで定義されているクラスitemsetsのものです。help(ore.itemsets)を参照してください。

例4-7では、トランザクション・データセットに基づいて、相関モデルを構築します。パッケージarulesおよびarulesVizは、生成されるルールおよびアイテムセットをクライアントのRセッションのメモリーにプルして表示するために必要です。このルールのグラフを図4-1に示します。

例4-7 ore.odmAssocRules関数の使用方法

# Load the arules and arulesViz packages.
library(arules)
library(arulesViz)
# Create some transactional data.
id <- c(1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3)
item <- c("b", "d", "e", "a", "b", "c", "e", "b", "c", "d", "e")
# Push the data to the database as an ore.frame object.
transdata_of <- ore.push(data.frame(ID = id, ITEM = item))
# Build a model with specifications.
ar.mod1 <- ore.odmAssocRules(~., transdata_of, case.id.column = "ID",
item.id.column = "ITEM", min.support = 0.6, min.confidence = 0.6,
max.rule.length = 3)
# Generate itemsets and rules of the model.
itemsets <- itemsets(ar.mod1)
rules <- rules(ar.mod1)
# Convert the rules to the rules object in arules package.
rules.arules <- ore.pull(rules)
inspect(rules.arules)
# Convert itemsets to the itemsets object in arules package.
itemsets.arules <- ore.pull(itemsets)
inspect(itemsets.arules)
# Plot the rules graph.
plot(rules.arules, method = "graph", interactive = TRUE)

例4-7のリスト

R> # Load the arules and arulesViz packages.
R> library(arules)
R> library(arulesViz)
R> # Create some transactional data.
R> id <- c(1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3)
R> item <- c("b", "d", "e", "a", "b", "c", "e", "b", "c", "d", "e")
R> # Push the data to the database as an ore.frame object.
R> transdata_of <- ore.push(data.frame(ID = id, ITEM = item))
R> # Build a model with specifications.
R> ar.mod1 <- ore.odmAssocRules(~., transdata_of, case.id.column = "ID",
+             item.id.column = "ITEM", min.support = 0.6, min.confidence = 0.6,
+             max.rule.length = 3)
R> # Generate itemsets and rules of the model.
R> itemsets <- itemsets(ar.mod1)
R> rules <- rules(ar.mod1)
R> # Convert the rules to the rules object in arules package.
R> rules.arules <- ore.pull(rules)
R> inspect(rules.arules)
lhs    rhs   support confidence lift
1  {b} => {e} 1.0000000  1.0000000    1
2  {e} => {b} 1.0000000  1.0000000    1
3  {c} => {e} 0.6666667  1.0000000    1
4  {d,
e} => {b} 0.6666667  1.0000000    1
5  {c,
e} => {b} 0.6666667  1.0000000    1
6  {b,
d} => {e} 0.6666667  1.0000000    1
7  {b,
c} => {e} 0.6666667  1.0000000    1
8  {d} => {b} 0.6666667  1.0000000    1
9  {d} => {e} 0.6666667  1.0000000    1
10 {c} => {b} 0.6666667  1.0000000    1
11 {b} => {d} 0.6666667  0.6666667    1
12 {b} => {c} 0.6666667  0.6666667    1
13 {e} => {d} 0.6666667  0.6666667    1
14 {e} => {c} 0.6666667  0.6666667    1
15 {b,
e} => {d} 0.6666667  0.6666667    1
16 {b,
e} => {c} 0.6666667  0.6666667    1
R> # Convert itemsets to the itemsets object in arules package.
R> itemsets.arules <- ore.pull(itemsets)
R> inspect(itemsets.arules)
items   support
1  {b}   1.0000000
2  {e}   1.0000000
3  {b,
e}   1.0000000
4  {c}   0.6666667
5  {d}   0.6666667
6  {b,
c}   0.6666667
7  {b,
d}   0.6666667
8  {c,
e}   0.6666667
9  {d,
e}   0.6666667
10 {b,
c,
e}   0.6666667
11 {b,
d,
e}   0.6666667

R> # Plot the rules graph.
R> plot(rules.arules, method = "graph", interactive = TRUE)

図4-1 相関ルールの視覚的デモンストレーション

属性評価モデルの構築

ore.odmAI関数は、Oracle Data Mining最小記述長アルゴリズムを使用して属性評価を計算します。属性評価では、ターゲットの予測における重要度に従って属性がランク付けされます。

最小記述長(MDL)は、情報理論モデルの選択原理の1つである。それは、情報理論(情報の定量化の研究)および学習理論(経験的データに基づく一般化の容量の研究)における重要な概念です。

MDLでは、最も単純でコンパクトな表現が、データの説明として最適かつ最も可能性が高いとみなされます。MDL原理は、Oracle Data Miningの属性評価モデルの作成に使用されます。

Oracle Data Miningを使用して構築された属性評価モデルは、新しいデータに適用できません。

ore.odmAI関数は、属性のランキングおよび属性評価の値を作成します。

注意:
OREdm AIモデルは、モデル・オブジェクトが保持されない、Rモデル・オブジェクトが返されない、という点で、Oracle Data Mining AIモデルとは異なります。モデルによって作成された重要度ランキングのみが返されます。

ore.odmAI関数の引数の詳細は、help(ore.odmAI)を呼び出してください。

例4-8では、data.frameのirisをデータベースにore.frameのiris_ofとしてプッシュします。この例では次に、属性評価モデルを構築します。

例4-8 ore.odmAI関数の使用方法

iris_of <- ore.push(iris)
ore.odmAI(Species ~ ., iris_of)

例4-8のリスト

R> iris_of <- ore.push(iris)
R> ore.odmAI(Species ~ ., iris_of)

Call:
ore.odmAI(formula = Species ~ ., data = iris_of)

Importance:
importance rank
Petal.Width   1.1701851    1
Petal.Length  1.1494402    2
Sepal.Length  0.5248815    3
Sepal.Width   0.2504077    4

ディシジョン・ツリー・モデルの構築

ore.odmDT関数は、Oracle Data Miningディシジョン・ツリー・アルゴリズムを使用しますが、これは条件付確率を基にしています。ディシジョン・ツリーはルールを生成します。ルールは、ユーザーが容易に理解でき、レコード・セットを識別するためにデータベース内で使用できる条件文です。

ディシジョン・ツリー・モデルは分類モデルです。

ディシジョン・ツリーは、一連の質問を問うことによってターゲット値を予測します。各段階で問われる質問はそれぞれ、直前の質問に対する回答によって決まります。最終的に特定のターゲット値を一意に識別できるような質問を重ねていきます。図形的には、このプロセスがツリー構造を形成します。

ディシジョン・ツリー・アルゴリズムは、トレーニング・プロセスにおいて、ケース(レコード)のセットを2つの子ノードに分割する最も効率的な方法を繰り返し見つける必要があります。ore.odmDT関数では、この分岐の計算用に2つの同種メトリック(giniおよびentropy)を使用できます。デフォルトのメトリックはginiです。

ore.odmDT関数の引数の詳細は、help(ore.odmDT)を呼び出してください。

例4-9では、入力ore.frameを作成し、モデルを構築し、予測を行い、混同マトリクスを生成します。

例4-9 ore.odmDT関数の使用方法

m <- mtcars
m$gear <- as.factor(m$gear)
m$cyl  <- as.factor(m$cyl)
m$vs   <- as.factor(m$vs)
m$ID   <- 1:nrow(m)
mtcars_of <- ore.push(m)
row.names(mtcars_of) <- mtcars_of
# Build the model.
dt.mod  <- ore.odmDT(gear ~ ., mtcars_of)
summary(dt.mod)
# Make predictions and generate a confusion matrix.
dt.res  <- predict (dt.mod, mtcars_of, "gear")
with(dt.res, table(gear, PREDICTION))

例4-9のリスト

R> m <- mtcars
R> m$gear <- as.factor(m$gear)
R> m$cyl  <- as.factor(m$cyl)
R> m$vs   <- as.factor(m$vs)
R> m$ID   <- 1:nrow(m)
R> mtcars_of <- ore.push(m)
R> row.names(mtcars_of) <- mtcars_of
R> # Build the model.
R> dt.mod  <- ore.odmDT(gear ~ ., mtcars_of)
R> summary(dt.mod)

Call:
ore.odmDT(formula = gear ~ ., data = mtcars_of)

n =  32

Nodes:
parent node.id row.count prediction                         split
1     NA       0        32          3                          <NA>
2      0       1        16          4 (disp <= 196.299999999999995)
3      0       2        16          3  (disp > 196.299999999999995)
surrogate                   full.splits
1                <NA>                          <NA>
2 (cyl in ("4" "6" )) (disp <= 196.299999999999995)
3     (cyl in ("8" ))  (disp > 196.299999999999995)

Settings:
value
prep.auto                    on
impurity.metric   impurity.gini
term.max.depth                7
term.minpct.node           0.05
term.minpct.split           0.1
term.minrec.node             10
term.minrec.split            20
R> # Make predictions and generate a confusion matrix.
R> dt.res  <- predict (dt.mod, mtcars_of, "gear")
R> with(dt.res, table(gear, PREDICTION))
PREDICTION
gear  3  4
3 14  1
4  0 12
5  2  3

一般化線形モデルの構築

ore.odmGLM関数は一般化線形モデル(GLM)を構築しますが、これは線形モデル(線形回帰)のクラスを含み、このクラスを拡張したものです。一般化線形モデルは、実際には違反されることが多い線形モデルの制限を緩和したものです。たとえば、2値(yes/noまたは0/1)応答は、クラス間で同じ分散を持ちません。

Oracle Data MiningのGLMはパラメトリック・モデリング手法です。パラメトリック・モデルでは、データの分散を仮定します。仮定が満たされる場合、パラメトリック・モデルはノンパラメトリック・モデルよりも効率的になります。

このタイプのモデルの作成では、どの程度仮定が満たされるかを見極めることが課題となります。このため、良質なパラメトリック・モデルを作成するには質の診断が重要です。

古典的な、線形回帰における重み付き最小二乗推定およびロジスティック回帰における反復再重み付き最小二乗推定(いずれもコレスキー分解およびマトリクス反転を使用する解決)に加えて、Oracle Data MiningのGLMでは、マトリクス反転が不要で高次元データに最適な共役勾配法に基づく最適化アルゴリズムを提供します。アルゴリズムの選択は内部的に処理され、ユーザーに対して透過的です。

GLMを使用して、次のような分類モデルまたは回帰モデルを構築できます。

- 分類: 2項ロジスティック回帰は、GLM分類アルゴリズムです。このアルゴリズムでは、ロジット・リンク関数および2項分散関数を使用します。

- 回帰: 線形回帰は、GLM回帰アルゴリズムです。このアルゴリズムでは、ターゲット値の範囲に対する一定分散およびターゲット変換を想定していません。

ore.odmGLM関数では、2つの異なるタイプのモデルを構築できます。一部、分類モデルにのみ適用される引数、回帰モデルにのみ適用される引数があります。

ore.odmGLM関数の引数の詳細は、help(ore.odmGLM)を呼び出してください。

次の例では、GLMを使用していくつかのモデルを構築します。入力ore.frameオブジェクトは、データベースにプッシュされるRデータセットです。

例4-10では、longleyデータセットを使用して線形回帰モデルを構築します。

例4-10 線形回帰モデルの構築

longley_of <- ore.push(longley)
longfit1 <- ore.odmGLM(Employed ~ ., data = longley_of)
summary(longfit1)

例4-10のリスト

R> longley_of <- ore.push(longley)
R> longfit1 <- ore.odmGLM(Employed ~ ., data = longley_of)
R> summary(longfit1)

Call:
ore.odmGLM(formula = Employed ~ ., data = longely_of)

Residuals:
Min       1Q   Median       3Q      Max
-0.41011 -0.15767 -0.02816  0.10155  0.45539

Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept)  -3.482e+03  8.904e+02  -3.911 0.003560 **
GNP.deflator  1.506e-02  8.492e-02   0.177 0.863141
GNP          -3.582e-02  3.349e-02  -1.070 0.312681
Unemployed   -2.020e-02  4.884e-03  -4.136 0.002535 **
Armed.Forces -1.033e-02  2.143e-03  -4.822 0.000944 ***
Population   -5.110e-02  2.261e-01  -0.226 0.826212
Year          1.829e+00  4.555e-01   4.016 0.003037 **
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

Residual standard error: 0.3049 on 9 degrees of freedom
Multiple R-squared:  0.9955,    Adjusted R-squared:  0.9925
F-statistic: 330.3 on 6 and 9 DF,  p-value: 4.984e-10

例4-11では、 例4-10のlongley_ofのore.frameを使用します。例4-11では、ore.odmGLM関数を呼び出し、係数のリッジ推定を使用して指定します。

例4-11 ore.odmGLMモデルの係数に対するリッジ推定の使用方法

longfit2 <- ore.odmGLM(Employed ~ ., data = longley_of, ridge = TRUE,
ridge.vif = TRUE)
summary(longfit2)

例4-11のリスト

R> longfit2 <- ore.odmGLM(Employed ~ ., data = longley_of, ridge = TRUE,
+                         ridge.vif = TRUE)
R> summary(longfit2)

Call:
ore.odmGLM(formula = Employed ~ ., data = longley_of, ridge = TRUE,
ridge.vif = TRUE)

Residuals:
Min      1Q  Median      3Q     Max
-0.4100 -0.1579 -0.0271  0.1017  0.4575

Coefficients:
Estimate   VIF
(Intercept)  -3.466e+03 0.000
GNP.deflator  1.479e-02 0.077
GNP          -3.535e-02 0.012
Unemployed   -2.013e-02 0.000
Armed.Forces -1.031e-02 0.000
Population   -5.262e-02 0.548
Year          1.821e+00 2.212

Residual standard error: 0.3049 on 9 degrees of freedom
Multiple R-squared:  0.9955,    Adjusted R-squared:  0.9925
F-statistic: 330.2 on 6 and 9 DF,  p-value: 4.986e-10

例4-12では、ロジスティック回帰(分類)モデルを構築します。ここでは、infertデータセットを使用します。この例では、ore.odmGLM関数を呼び出し、"logistic"をtype引数(二項分布GLMを構築します)として指定します。

例4-12 ロジスティック回帰GLMの構築

infert_of <- ore.push(infert)
infit1 <- ore.odmGLM(case ~ age+parity+education+spontaneous+induced,
data = infert_of, type = "logistic")
infit1

例4-12のリスト

R> infert_of <- ore.push(infert)
R> infit1 <- ore.odmGLM(case ~ age+parity+education+spontaneous+induced,
+                       data = infert_of, type = "logistic")
R> infit1

Response:
case == "1"

Call:  ore.odmGLM(formula = case ~ age + parity + education + spontaneous +
induced, data = infert_of, type = "logistic")

Coefficients:
(Intercept)               age            parity   education0-5yrs  education12+ yrs       spontaneous           induced
-2.19348           0.03958          -0.82828           1.04424          -0.35896           2.04590           1.28876

Degrees of Freedom: 247 Total (i.e. Null);  241 Residual
Null Deviance:      316.2
Residual Deviance: 257.8        AIC: 271.8

例4-13では、ロジスティック回帰(分類)モデルを構築し、参照値を指定します。この例では、例4-12のinfert_ofのore.frameを使用します。

例4-13 ロジスティック回帰GLMの構築での参照値の指定

infit2 <- ore.odmGLM(case ~ age+parity+education+spontaneous+induced,
data = infert_of, type = "logistic", reference = 1)
infit2

例4-13のリスト

infit2 <- ore.odmGLM(case ~ age+parity+education+spontaneous+induced,
data = infert_of, type = "logistic", reference = 1)
infit2

Response:
case == "0"

Call:  ore.odmGLM(formula = case ~ age + parity + education + spontaneous +
induced, data = infert_of, type = "logistic", reference = 1)

Coefficients:
(Intercept)               age            parity   education0-5yrs  education12+ yrs       spontaneous           induced
2.19348          -0.03958           0.82828          -1.04424           0.35896          -2.04590          -1.28876

Degrees of Freedom: 247 Total (i.e. Null);  241 Residual
Null Deviance:      316.2
Residual Deviance: 257.8        AIC: 271.8

k-Meansモデルの構築

ore.odmKM関数は、Oracle Data Miningのk-Means (KM)アルゴリズムを使用しますが、これは、指定した数のクラスタにデータを分割する、距離ベースのクラスタリング・アルゴリズムです。このアルゴリズムには、次の機能があります。

- 複数の距離関数(ユークリッド、コサインおよび高速コサインの各距離関数)。デフォルトはユークリッドです。

- クラスタごとに、アルゴリズムによって、重心、各属性のヒストグラム、およびクラスタに割り当てられるデータの大部分を囲むハイパーボックスを記述するルールが戻されます。重心は、カテゴリ属性については最頻値を、数値属性については平均および分散をレポートします。

ore.odmKM関数の引数の詳細は、help(ore.odmKM)を呼び出してください。

例4-14にore.odmKMeans関数の使用を示します。この例では、100行および2列を含むマトリクスを2つ作成します。行の値は無作為変量です。このマトリクスをmatrix xにバインドします。この例では、xをdata.frameに強制変換し、それをデータベースにore.frameオブジェクトであるx_ofとしてプッシュします。例では、ore.odmKMeans関数を呼び出して、KMモデルのkm.mod1を構築します。次に、summary関数およびhistogram関数をそのモデルで呼び出します。図4-2に、histogram関数で表示されるグラフを示します。

この例では次に、このモデルを使用して予測を行い、その結果をローカル・メモリーにプルします。結果が描画されます。図4-3に、この例のpoints関数で表示されるグラフを示します。

例4-14 ore.odmKM関数の使用方法

x <- rbind(matrix(rnorm(100, sd = 0.3), ncol = 2),
matrix(rnorm(100, mean = 1, sd = 0.3), ncol = 2))
colnames(x) <- c("x", "y")
x_of <- ore.push (data.frame(x))
km.mod1 <- NULL
km.mod1 <- ore.odmKMeans(~., x_of, num.centers=2)
summary(km.mod1)
histogram(km.mod1) # See Figure 4-2.
# Make a prediction.
km.res1 <- predict(km.mod1, x_of, type="class", supplemental.cols=c("x","y"))
head(km.res1, 3)
# Pull the results to the local memory and plot them.
km.res1.local <- ore.pull(km.res1)
plot(data.frame(x=km.res1.local$x, y=km.res1.local$y),
col=km.res1.local$CLUSTER_ID)
points(km.mod1$centers2, col = rownames(km.mod1$centers2), pch = 8, cex=2)
head(predict(km.mod1, x_of, type=c("class","raw"),
supplemental.cols=c("x","y")), 3)

例4-14のリスト

R> x <- rbind(matrix(rnorm(100, sd = 0.3), ncol = 2),
+             matrix(rnorm(100, mean = 1, sd = 0.3), ncol = 2))
R> colnames(x) <- c("x", "y")
R> x_of <- ore.push (data.frame(x))
R> km.mod1 <- NULL
R> km.mod1 <- ore.odmKMeans(~., x_of, num.centers=2)
R> summary(km.mod1)

Call:
ore.odmKMeans(formula = ~., data = x_of, num.centers = 2)

Settings:
value
clus.num.clusters            2
block.growth                 2
conv.tolerance            0.01
distance             euclidean
iterations                   3
min.pct.attr.support       0.1
num.bins                    10
split.criterion       variance
prep.auto                   on

Centers:
x           y
2  0.99772307  0.93368684
3 -0.02721078 -0.05099784
R> histogram(km.mod1) # See Figure 4-2.
R> # Make a prediction.
R> km.res1 <- predict(km.mod1, x_of, type="class", supplemental.cols=c("x","y"))
R> head(km.res1, 3)
x          y CLUSTER_ID
1 -0.03038444  0.4395409          3
2  0.17724606 -0.5342975          3
3 -0.17565761  0.2832132          3
# Pull the results to the local memory and plot them.
R> km.res1.local <- ore.pull(km.res1)
R> plot(data.frame(x=km.res1.local$x, y=km.res1.local$y),
+                  col=km.res1.local$CLUSTER_ID)
R> points(km.mod1$centers2, col = rownames(km.mod1$centers2), pch = 8, cex=2)
R> # See Figure 4-3.
R> head(predict(km.mod1, x_of, type=c("class","raw"),
supplemental.cols=c("x","y")), 3)
'2'       '3'           x          y CLUSTER_ID
1 8.610341e-03 0.9913897 -0.03038444  0.4395409          3
2 8.017890e-06 0.9999920  0.17724606 -0.5342975          3
3 5.494263e-04 0.9994506 -0.17565761  0.2832132          3

図4-2に、例4-14のhistogram関数の呼出しで表示されるグラフを示します。

図4-2 km.mod1モデルのクラスタ・ヒストグラム

図4-4に、例4-14のpoints関数の呼出しで表示されるグラフを示します。

図4-3 km.mod1モデルのpoints関数の結果

Naive Bayesモデルの構築

ore.odmNB関数は、Oracle Data MiningのNaive Bayesモデルを構築します。Naive Bayesアルゴリズムは条件付き確率に基づいています。Naive Bayesは履歴データを検索し、属性値の頻度と属性値の組合せの頻度を観測することによってターゲット値の条件付き確率を計算します。

Naive Bayesでは、各予測子は他の予測子とは条件的に独立していると想定されます。(Bayesの定理では、予測子が独立している必要があります。)

ore.odmNB関数の引数の詳細は、help(ore.odmNB)を呼び出してください。

例4-9では、入力ore.frameを作成し、Naive Bayesモデルを構築し、予測を行い、混同マトリクスを生成します。

例4-15 ore.odmNB関数の使用方法

m <- mtcars
m$gear <- as.factor(m$gear)
m$cyl  <- as.factor(m$cyl)
m$vs   <- as.factor(m$vs)
m$ID   <- 1:nrow(m)
mtcars_of <- ore.push(m)
row.names(mtcars_of) <- mtcars_of
# Build the model.
nb.mod  <- ore.odmNB(gear ~ ., mtcars_of)
summary(nb.mod)
# Make predictions and generate a confusion matrix.
nb.res  <- predict (nb.mod, mtcars_of, "gear")
with(nb.res, table(gear, PREDICTION))

例4-15のリスト

R> m <- mtcars
R> m$gear <- as.factor(m$gear)
R> m$cyl  <- as.factor(m$cyl)
R> m$vs   <- as.factor(m$vs)
R> m$ID   <- 1:nrow(m)
R> mtcars_of <- ore.push(m)
R> row.names(mtcars_of) <- mtcars_of
R> # Build the model.
R> nb.mod  <- ore.odmNB(gear ~ ., mtcars_of)
R> summary(nb.mod)

Call:
ore.odmNB(formula = gear ~ ., data = mtcars_of)

Settings:
value
prep.auto    on

Apriori:
3       4       5
0.46875 0.37500 0.15625
Tables:
$ID
( ; 26.5), [26.5; 26.5]  (26.5;  )
3              1.00000000
4              0.91666667 0.08333333
5                         1.00000000

$am
0         1
3 1.0000000
4 0.3333333 0.6666667
5           1.0000000

$cyl
'4', '6' '8'
3      0.2 0.8
4      1.0
5      0.6 0.4

$disp
( ; 196.299999999999995), [196.299999999999995; 196.299999999999995]
3                                                           0.06666667
4                                                           1.00000000
5                                                           0.60000000
(196.299999999999995;  )
3               0.93333333
4
5               0.40000000

$drat
( ; 3.385), [3.385; 3.385] (3.385;  )
3                  0.8666667  0.1333333
4                             1.0000000
5                             1.0000000
$hp
( ; 136.5), [136.5; 136.5] (136.5;  )
3                        0.2        0.8
4                        1.0
5                        0.4        0.6

$vs
0         1
3 0.8000000 0.2000000
4 0.1666667 0.8333333
5 0.8000000 0.2000000

$wt
( ; 3.2024999999999999), [3.2024999999999999; 3.2024999999999999]
3                                                        0.06666667
4                                                        0.83333333
5                                                        0.80000000
(3.2024999999999999;  )
3              0.93333333
4              0.16666667
5              0.20000000

Levels:
[1] "3" "4" "5"

R> # Make predictions and generate a confusion matrix.
R> nb.res  <- predict (nb.mod, mtcars_of, "gear")
R> with(nb.res, table(gear, PREDICTION))
PREDICTION
gear  3  4  5
3 14  1  0
4  0 12  0
5  0  1  4

Non-Negative Matrix Factorizationモデルの構築

ore.odmNMF関数は、特徴抽出にOracle Data MiningのNon-Negative Matrix Factorization (NMF)モデルを構築します。NMFによって抽出される各特徴は、元の属性セットの線形結合です。各特徴には、負でない一連の係数があり、それらは特徴の各属性の重みのメジャーです。引数allow.negative.scoresがTRUEの場合、負の係数が許可されます。

ore.odmNMF関数の引数の詳細は、help(ore.odmNMF)を呼び出してください。

例4-16では、NMFモデルをトレーニング・データセットに作成し、テスト・データセットでスコアリングします。

例4-16 ore.odmNMF関数の使用方法

training.set <- ore.push(npk[1:18, c("N","P","K")])
scoring.set <- ore.push(npk[19:24, c("N","P","K")])
nmf.mod <- ore.odmNMF(~., training.set, num.features = 3)
features(nmf.mod)
summary(nmf.mod)
predict(nmf.mod, scoring.set)

例4-16のリスト

R> training.set <- ore.push(npk[1:18, c("N","P","K")])
R> scoring.set <- ore.push(npk[19:24, c("N","P","K")])
R> nmf.mod <- ore.odmNMF(~., training.set, num.features = 3)
R> features(nmf.mod)
FEATURE_ID ATTRIBUTE_NAME ATTRIBUTE_VALUE  COEFFICIENT
1           1              K               0 3.723468e-01
2           1              K               1 1.761670e-01
3           1              N               0 7.469067e-01
4           1              N               1 1.085058e-02
5           1              P               0 5.730082e-01
6           1              P               1 2.797865e-02
7           2              K               0 4.107375e-01
8           2              K               1 2.193757e-01
9           2              N               0 8.065393e-03
10          2              N               1 8.569538e-01
11          2              P               0 4.005661e-01
12          2              P               1 4.124996e-02
13          3              K               0 1.918852e-01
14          3              K               1 3.311137e-01
15          3              N               0 1.547561e-01
16          3              N               1 1.283887e-01
17          3              P               0 9.791965e-06
18          3              P               1 9.113922e-01
R> summary(nmf.mod)

Call:
ore.odmNMF(formula = ~., data = training.set, num.features = 3)

Settings:
value
feat.num.features                                 3
nmfs.conv.tolerance                             .05
nmfs.nonnegative.scoring nmfs.nonneg.scoring.enable
nmfs.num.iterations                              50
nmfs.random.seed                                 -1
prep.auto                                        on

Features:
FEATURE_ID ATTRIBUTE_NAME ATTRIBUTE_VALUE  COEFFICIENT
1           1              K               0 3.723468e-01
2           1              K               1 1.761670e-01
3           1              N               0 7.469067e-01
4           1              N               1 1.085058e-02
5           1              P               0 5.730082e-01
6           1              P               1 2.797865e-02
7           2              K               0 4.107375e-01
8           2              K               1 2.193757e-01
9           2              N               0 8.065393e-03
10          2              N               1 8.569538e-01
11          2              P               0 4.005661e-01
12          2              P               1 4.124996e-02
13          3              K               0 1.918852e-01
14          3              K               1 3.311137e-01
15          3              N               0 1.547561e-01
16          3              N               1 1.283887e-01
17          3              P               0 9.791965e-06
18          3              P               1 9.113922e-01
R> predict(nmf.mod, scoring.set)
'1'       '2'        '3' FEATURE_ID
19 0.1972489 1.2400782 0.03280919          2
20 0.7298919 0.0000000 1.29438165          3
21 0.1972489 1.2400782 0.03280919          2
22 0.0000000 1.0231268 0.98567623          2
23 0.7298919 0.0000000 1.29438165          3
24 1.5703239 0.1523159 0.00000000          1

直交パーティショニング・クラスタ・モデルの構築

ore.odmOC関数は、直交パーティショニング・クラスタ(O-Cluster)アルゴリズムを使用してOracle Data Miningモデルを構築します。O-Clusterアルゴリズムは、グリッドベースの階層クラスタリング・モデルを構築しますが、つまり、軸並行な(直行の)パーティションを入力属性空間に作成します。このアルゴリズムは再帰的に作用します。生成される階層構造は、属性空間をクラスタに分割する不規則なグリッドになります。生成されるクラスタは、属性空間内の密度の高い領域を定義します。

クラスタは、属性軸沿いの間隔と、対応する重心およびヒストグラムによって記述されます。sensitivity引数は、基準となる密度レベルを定義します。最大密度がこの基準水準を上回る領域のみがクラスタとして認識されます。

k-Meansアルゴリズムの場合、自然なクラスタが存在しない可能性があっても、空間を分割します。たとえば、密度が均一な領域がある場合、k-Meansは、その領域をn個のクラスタ(nはユーザーが指定します)に分割します。O-Clusterは、低密度の領域に切断面を配置して、高密度の領域を切り離します。O-Clusterでは、複数の最頻値を持つヒストグラム(ピークと谷)を必要とします。ある領域に、密度が均一または単調に変化している投影がある場合、O-Clusterはその領域をパーティション化しません。

O-Clusterによって発見されたクラスタを使用して、ベイズ確率モデルが生成され、このモデルがpredict関数によるスコアリングの際に使用され、データ・ポイントをクラスタに割り当てます。生成される確率モデルは混合モデルで、混合要素は、量的属性の独立正規分布と質的属性の多項分布の積によって表されます。

O-Cluster用のデータをユーザー自身が準備する場合は、次の点に留意してください。

- O-Clusterアルゴリズムでは、モデルを構築する際に、必ずしもすべての入力データを使用するわけではありません。O-Clusterは、データをバッチで読み込みます(デフォルトのバッチ・サイズは50,000)。統計テストに基づいて、まだ見つかっていないクラスタが存在すると考えられる場合にのみ、別のバッチを読み込みます。

- O-Clusterは、すべてのデータを読み込むことなくモデルの作成を停止する場合があるので、データをランダム化しておくことをお薦めします。

- 2項属性は、質的属性として宣言する必要があります。O-Clusterは、質的データを数値にマップします。

- ビンの必要数の概算が自動化されたOracle Data Miningの等幅ビニング変換を使用することを強くお薦めします。

- 外れ値が存在すると、クラスタリング・アルゴリズムに大きな影響を与える可能性があります。ビニングまたは正規化を行う前に、クリッピング変換を実行してください。等幅ビニングで外れ値が存在すると、O-Clusterでクラスタを検出できなくなる場合があります。その結果、母集団全体が1つのクラスタ内に含まれているように見えます。

formula引数の仕様には~ termsがあり、ここでtermsはモデルに含まれる列名です。複数のterms項目は列名の間に+を使用することで指定されます。~ .は、dataのすべての列をモデル構築に使用する場合に使用します。列を除外するには、除外する各列名の前に-を使用します。

ore.odmOC関数の引数の詳細は、help(ore.odmOC)を呼び出してください。

例4-17では、OCモデルを統合データセットに作成します。図4-4に、生成されるクラスタのヒストグラムを示します。

例4-17 ore.odmOC関数の使用方法

x <- rbind(matrix(rnorm(100, mean = 4, sd = 0.3), ncol = 2),
matrix(rnorm(100, mean = 2, sd = 0.3), ncol = 2))
colnames(x) <- c("x", "y")
x_of <- ore.push (data.frame(ID=1:100,x))
rownames(x_of) <- x_of$ID
oc.mod <- ore.odmOC(~., x_of, num.centers=2)
summary(oc.mod)

例4-17のリスト

R> x <- rbind(matrix(rnorm(100, mean = 4, sd = 0.3), ncol = 2),
+             matrix(rnorm(100, mean = 2, sd = 0.3), ncol = 2))
R> colnames(x) <- c("x", "y")
R> x_of <- ore.push (data.frame(ID=1:100,x))
R> rownames(x_of) <- x_of$ID
R> oc.mod <- ore.odmOC(~., x_of, num.centers=2)
R> summary(oc.mod)

Call:
ore.odmOC(formula = ~., data = x_of, num.centers = 2)

Settings:
value
clus.num.clusters     2
max.buffer        50000
sensitivity         0.5
prep.auto            on

Clusters:
CLUSTER_ID ROW_CNT PARENT_CLUSTER_ID TREE_LEVEL DISPERSION IS_LEAF
1          1     100                NA          1         NA   FALSE
2          2      56                 1          2         NA    TRUE
3          3      43                 1          2         NA    TRUE

Centers:
MEAN.x   MEAN.y
2 1.85444 1.941195
3 4.04511 4.111740
R> histogram(oc.mod)     # See Figure 4-4.
R> predict(oc.mod, x_of, type=c("class","raw"), supplemental.cols=c("x","y"))
'2'          '3'        x        y CLUSTER_ID
1   3.616386e-08 9.999999e-01 3.825303 3.935346          3
2   3.253662e-01 6.746338e-01 3.454143 4.193395          3
3   3.616386e-08 9.999999e-01 4.049120 4.172898          3
# ... Intervening rows not shown.
98  1.000000e+00 1.275712e-12 2.011463 1.991468          2
99  1.000000e+00 1.275712e-12 1.727580 1.898839          2
100 1.000000e+00 1.275712e-12 2.092737 2.212688          2

図4-4 ore.odmOCモデルのhistogram関数の出力

サポート・ベクター・マシン・モデルの構築

ore.odmSVM関数は、Oracle Data Miningのサポート・ベクター・マシン(SVM)モデルを構築します。SVMは、Vapnik-Chervonenkis理論に基づいた強固な理論的基礎を持つ最新の強力なアルゴリズムです。SVMは、強力な正則化プロパティを持ちます。正則化とは、新しいデータへのモデルの一般化を指します。

SVMモデルは、一般的なデータ・マイニング手法であるニューラル・ネットワークおよび動径基底関数に似た関数形式を持ちます。

SVMは、次のような問題の解決に使用できます。

- 分類: SVM分類は、決定境界を定義する決定面の概念に基づいています。決定面は、異なるクラスのメンバーシップを持つオブジェクト・セット間を区別するものです。SVMは、クラスの最も広範な区切りを与えるセパレータを定義するベクター(サポート・ベクター)を検出します。
SVM分類では、2項および多クラスの両ターゲットがサポートされます。

- 回帰: SVMでは、回帰問題を解決するために、イプシロン非感受性損失関数が使用されます。
SVM回帰では、データ・ポイントの最大数がイプシロン幅の非感受性チューブ内に収まるような連続関数の検出が試行されます。真のターゲット値のイプシロン距離内におさまる予測は、誤差として解釈されません。

- 異常検出: 異常検出は、一見同質なデータ内に存在する特異なケースを識別します。異常検出は、重大な意味を持ちながら検出することが難しい、不正行為、ネットワークへの侵入などの発生頻度の低いイベントを検出するための重要なツールです。
異常検出は、1クラスSVM分類として実装されます。異常検出モデルでは、あるデータ・ポイントが特定の分布に対して典型的かどうかを予測します。

ore.odmSVM関数は、次の3つの異なるタイプのモデルを構築します。一部、分類モデルにのみ適用される引数、回帰モデルにのみ適用される引数、異常検出モデルにのみ適用される引数があります。

ore.odmSVM関数の引数の詳細は、help(ore.odmSVM)を呼び出してください。

例4-18に、SVM分類の使用を示します。この例では、Rのmtcarsデータセットからデータベースにmtcarsを作成し、分類モデルを構築し、予測を行い、最終的に、混同マトリクスを生成します。

例4-18 ore.odmSVM関数の使用方法および混同マトリクスの生成

m <- mtcars
m$gear <- as.factor(m$gear)
m$cyl  <- as.factor(m$cyl)
m$vs   <- as.factor(m$vs)
m$ID   <- 1:nrow(m)
mtcars_of <- ore.push(m)
svm.mod  <- ore.odmSVM(gear ~ .-ID, mtcars_of, "classification")
summary(svm.mod)
svm.res  <- predict (svm.mod, mtcars_of,"gear")
with(svm.res, table(gear, PREDICTION))  # generate confusion matrix

例4-18のリスト

R> m <- mtcars
R> m$gear <- as.factor(m$gear)
R> m$cyl  <- as.factor(m$cyl)
R> m$vs   <- as.factor(m$vs)
R> m$ID   <- 1:nrow(m)
R> mtcars_of <- ore.push(m)
R>
R> svm.mod  <- ore.odmSVM(gear ~ .-ID, mtcars_of, "classification")
R> summary(svm.mod)
Call:
ore.odmSVM(formula = gear ~ . - ID, data = mtcars_of, type = "classification")

Settings:
value
prep.auto                on
active.learning   al.enable
complexity.factor  0.385498
conv.tolerance        1e-04
kernel.cache.size  50000000
kernel.function    gaussian
std.dev            1.072341

Coefficients:
[1] No coefficients with gaussian kernel
R> svm.res  <- predict (svm.mod, mtcars_of,"gear")
R> with(svm.res, table(gear, PREDICTION))  # generate confusion matrix
PREDICTION
gear  3  4
3 12  3
4  0 12
5  2  3

例4-18に、SVM回帰を示します。この例では、データ・フレームを作成し、それを表にプッシュしてから、回帰モデルを構築します(ore.odmSVMでは、線形カーネルを指定します)。

例4-19 ore.odmSVM関数の使用方法および回帰モデルの構築

x <- seq(0.1, 5, by = 0.02)
y <- log(x) + rnorm(x, sd = 0.2)
dat <-ore.push(data.frame(x=x, y=y))

# Build model with linear kernel
svm.mod <- ore.odmSVM(y~x,dat,"regression", kernel.function="linear")
summary(svm.mod)
coef(svm.mod)
svm.res <- predict(svm.mod,dat, supplemental.cols="x")
head(svm.res,6)

例4-18のリスト

R> x <- seq(0.1, 5, by = 0.02)
R> y <- log(x) + rnorm(x, sd = 0.2)
R> dat <-ore.push(data.frame(x=x, y=y))
R>
R> # Build model with linear kernel
R> svm.mod <- ore.odmSVM(y~x,dat,"regression", kernel.function="linear")
R> summary(svm.mod)

Call:
ore.odmSVM(formula = y ~ x, data = dat, type = "regression",
kernel.function = "linear")

Settings:
value
prep.auto                on
active.learning   al.enable
complexity.factor  0.620553
conv.tolerance        1e-04
epsilon            0.098558
kernel.function      linear

Residuals:
Min.  1st Qu.   Median     Mean  3rd Qu.     Max.
-0.79130 -0.28210 -0.05592 -0.01420  0.21460  1.58400

Coefficients:
variable value  estimate
1           x       0.6637951
2 (Intercept)       0.3802170

R> coef(svm.mod)
variable value  estimate
1           x       0.6637951
2 (Intercept)       0.3802170
R> svm.res <- predict(svm.mod,dat, supplemental.cols="x")
R> head(svm.res,6)
x PREDICTION
1 0.10 -0.7384312
2 0.12 -0.7271410
3 0.14 -0.7158507
4 0.16 -0.7045604
5 0.18 -0.6932702
6 0.20 -0.6819799

このSVN異常検出の例では、分類の例で作成されたmtcars_ofを使用し、異常検出モデルを構築します。

例4-20 ore.odmSVM関数の使用方法および異常検出モデルの構築

svm.mod  <- ore.odmSVM(~ .-ID, mtcars_of, "anomaly.detection")
summary(svm.mod)
svm.res  <- predict (svm.mod, mtcars_of, "ID")
head(svm.res)
table(svm.res$PREDICTION)

例4-18のリスト

R> svm.mod  <- ore.odmSVM(~ .-ID, mtcars_of, "anomaly.detection")
R> summary(svm.mod)

Call:
ore.odmSVM(formula = ~. - ID, data = mtcars_of, type = "anomaly.detection")

Settings:
value
prep.auto                on
active.learning   al.enable
conv.tolerance        1e-04
kernel.cache.size  50000000
kernel.function    gaussian
outlier.rate             .1
std.dev            0.719126

Coefficients:
[1] No coefficients with gaussian kernel

R> svm.res  <- predict (svm.mod, mtcars_of, "ID")
R> head(svm.res)
'0'       '1' ID PREDICTION
Mazda RX4         0.4999405 0.5000595  1          1
Mazda RX4 Wag     0.4999794 0.5000206  2          1
Datsun 710        0.4999618 0.5000382  3          1
Hornet 4 Drive    0.4999819 0.5000181  4          1
Hornet Sportabout 0.4949872 0.5050128  5          1
Valiant           0.4999415 0.5000585  6          1
R> table(svm.res$PREDICTION)

0  1
5 27

5 Rモデルでの予測

予測モデルにより過去の動作に基づいて将来の動作を予測できます。モデルを構築した後に、そのモデルを使用して新しいデータのスコアリング、すなわち予測を行います。

Rにより様々なモデルを構築できます。Rモデルを使用して新しい結果を予測するためにデータのスコアリングをするときは、スコアリングするデータはR data.frameにある必要があります。ore.predict関数を使用すると、Rモデルを使用してore.frameオブジェクトにあるデータベース常駐データをスコアリングできます。

ore.predict関数を使用すると、ore.frameオブジェクトを使用した予測のみが可能であるため、モデルの再構築はできません。スケーラビリティおよびパフォーマンスを向上するには、第4章「Oracle R Enterpriseでのモデルの構築」に記載されているアルゴリズムおよび関数を使用してデータベース表にモデルを構築します。これらには、Oracle R Enterpriseに固有のアルゴリズムおよびRで公開されているOracle Data Miningのアルゴリズムの両方が含まれます。

ore.predict関数は汎用関数です。次のように使用します。

ore.predict(object, newdata, ...)

object引数の値は、Rモデルまたは表5-1にリストされているオブジェクトのいずれかです。newdata引数の値は、スコアリングするデータが含まれているore.frameオブジェクトです。OREpredictパッケージには、固有のRモデル・クラスで使用するためのメソッドがあります。...引数は、各種のメソッドで受け入れられる様々な追加の引数を表します。

表5-1に、汎用のore.predict関数で使用されるメソッド、メソッドがobject引数として受け入れるオブジェクトのクラスおよびモデルまたはオブジェクトのタイプの説明をリストします。

表5-1 汎用のore.predict関数のメソッド

OREpredictメソッド

オブジェクトのクラス

オブジェクトの説明

ore.predict-glm

glm

一般化線形モデル

ore.predict-kmeans

kmeans

k-Meansクラスタリング・モデル

ore.predict-lm

lm

線形回帰モデル

ore.predict-matrix

matrix

1000行以下のmatrix

ore.predict-multinom

multinom

多項対数線形モデル

ore.predict-nnet

nnet

ニューラル・ネットワーク・モデル

ore.predict-ore.model

ore.model

Oracle R Enterpriseのモデル

ore.predict-prcomp

prcomp

マトリクス上の主要コンポーネント分析

ore.predict-princomp

princomp

数値マトリクス上の主要コンポーネント分析

ore.predict-rpart

rpart

再帰分割および回帰ツリー・モデル

ore.predictメソッドの引数では、メソッドでhelp("ore.predict-glm")などのhelp関数を起動します。

例5-1では、iris data.frameでlm関数を使用して線形回帰モデル(irisModel)を構築します。ここでは、データセットをore.frameオブジェクトであるiris_ofとしてデータベースにプッシュします。次に、ore.predictをそこで起動してモデルをスコアリングします。

例5-1 LMモデルでのore.predict関数の使用方法

irisModel <- lm(Sepal.Length ~ ., data = iris)
iris_of <- ore.push(iris)
iris_of_pred <- ore.predict(irisModel, iris_of, se.fit = TRUE,
interval = "prediction")
iris_of <- cbind(iris_of, iris_of_pred)
head(iris_of)

例5-1のリスト

R> irisModel <- lm(Sepal.Length ~ ., data = iris)
R> iris_of <- ore.push(iris)
R> iris_of_pred <- ore.predict(irisModel, iris_of, se.fit = TRUE,
+                              interval = "prediction")
R> iris_of <- cbind(iris_of, iris_of_pred)
R> head(iris_of)
Sepal.Length Sepal.Width Petal.Length Petal.Width Species     PRED    SE.PRED
1          5.1         3.5          1.4         0.2  setosa 5.004788 0.04479188
2          4.9         3.0          1.4         0.2  setosa 4.756844 0.05514933
3          4.7         3.2          1.3         0.2  setosa 4.773097 0.04690495
4          4.6         3.1          1.5         0.2  setosa 4.889357 0.05135928
5          5.0         3.6          1.4         0.2  setosa 5.054377 0.04736842
6          5.4         3.9          1.7         0.4  setosa 5.388886 0.05592364
LOWER.PRED UPPER.PRED
1   4.391895   5.617681
2   4.140660   5.373027
3   4.159587   5.386607
4   4.274454   5.504259
5   4.440727   5.668026
6   4.772430   6.005342

R> head(iris_of)
Sepal.Length Sepal.Width Petal.Length Petal.Width Species     PRED    SE.PRED LOWER.PRED UPPER.PRED
1          5.1         3.5          1.4         0.2  setosa 5.004788 0.04479188   4.391895   5.617681
2          4.9         3.0          1.4         0.2  setosa 4.756844 0.05514933   4.140660   5.373027
3          4.7         3.2          1.3         0.2  setosa 4.773097 0.04690495   4.159587   5.386607
4          4.6         3.1          1.5         0.2  setosa 4.889357 0.05135928   4.274454   5.504259
5          5.0         3.6          1.4         0.2  setosa 5.054377 0.04736842   4.440727   5.668026
6          5.4         3.9          1.7         0.4  setosa 5.388886 0.05592364   4.772430   6.005342

例5-2では、infertデータセットを使用して一般化線形モデルを生成した後に、そのモデルでore.predict関数を起動します。

例5-2 GLMモデルでのore.predict関数の使用方法

infertModel <-
glm(case ~ age + parity + education + spontaneous + induced,
data = infert, family = binomial())
INFERT <- ore.push(infert)
INFERTpred <- ore.predict(infertModel, INFERT, type = "response",
se.fit = TRUE)
INFERT <- cbind(INFERT, INFERTpred)
head(INFERT)

例5-2のリスト

R> infertModel <-
+   glm(case ~ age + parity + education + spontaneous + induced,
+   data = infert, family = binomial())
R> INFERT <- ore.push(infert)
R> INFERTpred <- ore.predict(infertModel, INFERT, type = "response",
+                           se.fit = TRUE)
R> INFERT <- cbind(INFERT, INFERTpred)
R> head(INFERT)
education age parity induced case spontaneous stratum pooled.stratum
1    0-5yrs  26      6       1    1           2       1              3
2    0-5yrs  42      1       1    1           0       2              1
3    0-5yrs  39      6       2    1           0       3              4
4    0-5yrs  34      4       2    1           0       4              2
5   6-11yrs  35      3       1    1           1       5             32
6   6-11yrs  36      4       2    1           1       6             36
PRED    SE.PRED
1 0.5721916 0.20630954
2 0.7258539 0.17196245
3 0.1194459 0.08617462
4 0.3684102 0.17295285
5 0.5104285 0.06944005
6 0.6322269 0.10117919

6 Oracle R Enterpriseの埋込みRの実行の使用方法

埋込みRの実行は、Oracle R Enterpriseの重要な機能です。この章では、埋込みRの実行について、次の各項で説明します。

- Oracle R Enterpriseの埋込みRの実行について

- スクリプトのセキュリティに関する考慮事項

- パラレル実行のサポート

- 埋込みRの実行で使用するためのサード・パーティのパッケージのインストール

- 埋込みRの実行用のRインタフェース

- 埋込みRの実行用のSQLインタフェース

Oracle R Enterpriseの埋込みRの実行について

Oracle R Enterpriseでは、埋込みRの実行は、RスクリプトをOracle Databaseに格納して起動する機能であり、このスクリプトはその後、データベース内で実行され、データベースによって動的に開始および管理される1つ以上のRエンジンで実行されます。Oracle R Enterpriseでは、埋込みRの実行用にRインタフェースとSQLインタフェースの両方が提供されています。同じRスクリプトから、構造化データ、RオブジェクトおよびイメージのXML表現、さらにはデータベース表のBLOB列を介してPNGイメージを取得できます。

この項の内容は次のとおりです。

- 埋込みRの実行の利点

- 埋込みRの実行用のAPI

埋込みRの実行の利点

埋込みRの実行には次の利点があります。

- Oracle DatabaseサーバーからローカルのRセッションへデータを移動する必要がありません。
セキュリティを向上するでなく、Oracle Databaseと内部Rエンジン間のデータベース・データの転送は、別個のクライアントRエンジンよりはるかに高速です。

- データベース・サーバーを使用して、データベース側RエンジンのRスクリプトの実行を開始、管理および制御します。

- Rエンジンの実行に、データベース・サーバー・マシンのメモリーおよび処理能力を活用することで、より優れたスケーラビリティおよびパフォーマンスを提供します。

- Hadoopのマップ/リデュース・ジョブの特殊なケースに対応したユーザー定義のR関数をデータ・パラレルおよびタスク・パラレルに実行できます。

- パラレル・シミュレーション機能が装備されています。

- データベース・サーバー・マシンでオープン・ソースのCRANパッケージを使用できます。

- R環境を終了することなく、分析アプリケーション用の包括的なスクリプトを1つの手順で開発および操作できるようにする機能が装備されています。
探索的分析で使用されるRスクリプトをアプリケーション・タスクに直接統合できます。また、移植を排除し、アプリケーション・コードに対する変更の即時更新を可能にすることによって、本番でRスクリプトをすばやく起動して、開発期間を大幅に減少できます。

- SQLからRスクリプトを実行することで、Rスクリプトの結果をOracle Business Intelligence Enterprise Edition (OBIEE)、Oracle BI Publisherおよび構造化データ、Rオブジェクトおよびイメージ用のその他のSQL対応のツールと統合できます。

埋込みRの実行用のAPI

Oracle R Enterpriseには、埋込みRの実行用のRおよびSQLのアプリケーション・プログラミング・インタフェースがあります。表6-1に、埋込みRの実行関数のサマリーおよび使用可能なRスクリプトのリポジトリ関数を示します。関数fは、ユーザー定義のRコード(スクリプト)を参照し、このコードはR関数オブジェクトまたはデータベースのRスクリプト・リポジトリの指定されたR関数のいずれかとして提供されています。

表6-1 埋込みRの実行用のRおよびSQLのAPI

RのAPI

SQLのAPI

説明

ore.doEval

rqEval

データを自動転送せずにfを実行します。

ore.tableApply

rqTableEval

fの最初の引数として指定された入力ore.frameのすべての行を渡すことでfを実行します。fの最初の引数をdata.frameとして指定します。

ore.groupApply

rqGroupEval

この関数は、ユーザーが明示的に定義する必要があります。

グループ化列の値に応じてデータをパーティショニングすることでfを実行します。各データ・パーティションをfの最初の引数にdata.frameとして指定します。データベースのサーバー側Rエンジンで各f呼出しのパラレル実行をサポートします。

ore.rowApply

rqRowEval

指定された入力ore.frameの指定された行数(チャンク)を渡すことでfを実行します。各チャンクをfの最初の引数にdata.frameとして指定します。データベースのサーバー側Rエンジンで各f呼出しのパラレル実行をサポートします。

ore.indexApply

該当するものはありません。

データの自動転送なしでfを実行しますが、1からn (nは呼び出す関数の数)の呼出しの索引を指定します。データベースのサーバー側Rエンジンで各f呼出しのパラレル実行をサポートします。

ore.scriptCreate

sys.rqScriptCreate

指定されたR関数をRスクリプト・リポジトリに指定された名前でロードします。

ore.scriptDrop

sys.rqScriptDrop

指定されたR関数をRスクリプト・リポジトリから削除します。

スクリプトのセキュリティに関する考慮事項

RスクリプトおよびSQLスクリプトはどちらもデータベース・サーバーへのアクセスを許可するため、スクリプトの作成を制御する必要があります。RQADMINロールはOracle Database権限の集合で、スクリプトを作成してOracle DatabaseのRスクリプト・リポジトリに格納したり、リポジトリからスクリプトを削除するために、ユーザーが持つ必要のある権限です。

Oracle R EnterpriseをインストールするとRQADMINロールが作成されます。このロールは、明示的にユーザーに付与する必要があります。RQADMINをユーザーに付与するには、SQL*Plusをsysdbaで起動し、次のようなGRANT文(ロールをユーザーRQUSERに付与します)を入力します。

GRANT RQADMIN to RQUSER

注意:
RQADMINは、必要とするユーザーにのみ付与してください。

関連項目:

- 「埋込みRの実行用のAPI」

- 「ore.scriptCreate関数およびore.scriptDrop関数の使用方法」

- 「SQLスクリプトの登録および管理」

パラレル実行のサポート

Oracle R Enterpriseの埋込みRの実行関数の一部では、データベースでのパラレル実行の使用がサポートされています。ore.groupApply関数およびore.rowApply関数は、データ・パラレル実行をサポートし、ore.indexApply関数は、タスク・パラレル実行をサポートします。このパラレル実行機能によって、Oracle Exadataデータベース・マシンなどの高パフォーマンスのコンピューティング・ハードウェアをスクリプトで利用できます。

これらの関数のparallel引数には、埋込みRの実行で使用するための並列度を指定します。引数の値には、次のいずれかを指定できます。

- 特定の並列度では、2以上の正の整数

- パラレル化しない場合は、FALSEまたは1

- data引数のデフォルトのパラレル化の場合はTRUE

- 操作に対するデータベースのデフォルトはNULL

この引数のデフォルト値は、グローバル・オプションore.parallelの値、またはore.parallelが設定されていない場合はFALSEです。

ore.doEvalまたはore.tableApplyを使用して呼び出したユーザー定義のR関数は、並行して実行されません。このような関数は1つのRエンジンで実行されます。

ore.groupApply関数のデータ・パラレル実行では、1つ以上のRエンジンが同じR関数(タスク)をデータの別のパーティションで実行します。この機能によって、たとえば何万または何十万もの予測モデルを顧客に1モデルずつ構築するなどの、多数のモデルの構築が可能です。

ore.rowApply関数のデータ・パラレル実行では、1つ以上のRエンジンが同じR関数をデータの非結合チャンクで実行します。この機能によって、大規模なデータセットでのスケーラブルなモデルのスコアリングおよび予測が可能です。

ore.indexApply関数のタスク・パラレル実行では、1つ以上のRエンジンが同じまたは異なる計算(タスク)を実行します。実行の索引に関連付けられている数字が、関数に提供されます。この機能は、シミュレーションの実行などの各種の操作で重要です。

Oracle Databaseは、複合的である可能性のあるRエンジンの管理および制御をデータベース・サーバーで処理し、自動的にパーティショニングしてデータをRエンジンに渡して並行して実行します。すべてのパーティションですべてのR関数の実行が完了することが保証されますが、そうでない場合はOracle R Enterpriseの関数はエラーを返します。各ユーザー定義の埋込みR関数の実行結果は、ore.listに収集されます。このリストは、ユーザーが結果を要求するまでデータベースに保持されます。

埋込みRの実行では、Comprehensive R Archive Network (CRAN)のオープン・ソースのRパッケージまたは他のサード・パーティのRパッケージの関数を使用する可能性のあるユーザー定義のR関数のデータ・パラレル実行も可能です。ただし、サード・パーティのパッケージは、データベース内並列性を活用しないため、Rの並列性制約の対象となります。サード・パーティのパッケージは、埋込みRの実行でサポートされているデータ・パラレル実行およびタスク・パラレル実行を利用できます。

関連項目:
「Oracle R Enterpriseのグローバル・オプション」

埋込みRの実行で使用するためのサード・パーティのパッケージのインストール

埋込みRの実行では、Oracle Databaseサーバーで実行されるユーザー定義のR関数で、CRANまたは他のサード・パーティのパッケージを使用できます。埋込みRの実行でサード・パーティのパッケージを使用するには、そのパッケージをデータベース・サーバーにインストールする必要があります。埋込みRの実行用のRインタフェースでこのパッケージを使用する場合は、パッケージをクライアントにもインストールする必要があります。

埋込みRの実行ではCRANパッケージを使用するためにユーザー定義のR関数を使用できますが、オープン・ソースRパッケージはデータベース内並列性を活用しないため、Rの並列性制約の対象となります。CRANパッケージは、埋込みRの実行でサポートされているデータ・パラレル実行およびタスク・パラレル実行を利用できます。

埋込みRの実行では、データベース・サーバー(Oracle Exadataデータベース・マシンなど)上の一般的なRクライアント・マシンよりも多量である可能性の高いメモリーおよびプロセッサ数を利用します。埋込みRの実行では、データベースとRエンジンが同じマシン上にあるため、これらの間でさらに効率的なデータの転送が提供されます。

サード・パーティのパッケージは、Rセッションまたはコマンドラインからインストールできます。Rセッションでのパッケージのインストールの詳細は、「クライアントでのサード・パーティのパッケージの使用方法」を参照してください。

任意のRユーザーおよび埋込みRの実行で使用できるようにパッケージをサーバーにインストールするには、通常、Oracle Database管理者(DBA)がコマンドラインまたは管理ツールからコマンドを実行します。

通常、DBAは次の手順を実行します。

1. wgetを使用してCRANからパッケージ・ソースをダウンロードします。パッケージが使用していないR Distributionのパッケージに依存している場合は、そのパッケージのソースもダウンロードします。

2. 次のいずれかを実行します。

- 単一のOracle Databaseインスタンスでは、ORE CMD INSTALLコマンドを使用してOracle R Enterpriseパッケージと同じ場所($ORACLE_HOME/R/library)にパッケージをインストールします。

- Oracle Real Application Clusters (Oracle RAC)や複数ノードのOracle Exadataデータベース・マシン環境などの複数のデータベース・サーバーにインストールする場合は、Exadata Distributed Command Line Interface (DCLI)ユーティリティを使用します。単一ノードにパッケージをインストールするには、ORE CMD INSTALLコマンドを使用します。

例6-1に、CRANからarulesパッケージのソースを取得し、LinuxコマンドラインからのORE CMD INSTALLを使用したインストールを示します。

例6-1 単一のデータベースへのパッケージのインストール

wget http://cran.r-project.org/src/contrib/arules_1.1-1.tar.gz
ORE CMD INSTALL arules_1.1-1.tar.gz

例6-2に、arulesパッケージをインストールするためのDLCIコマンドを示します。

例6-2 DCLIを使用したパッケージのインストール

dcli -t -g nodes -l oracle R CMD INSTALL arules_1.1-1.tar.gz

関連項目:

- DCLIの設定およびパッケージのインストールの詳細は、『Oracle R Enterpriseインストレーションおよび管理ガイド』を参照してください。

- 「クライアントでのサード・パーティのパッケージの使用方法」

- http://www.r-bloggers.com/installing-r-packages/

埋込みRの実行用のRインタフェース

Oracle R Enterpriseには、Oracle Databaseに埋め込まれている1つ以上のRエンジンで実行するRスクリプトを起動する関数があります。その他の関数は、データベースのスクリプト・リポジトリに格納されるか、リポジトリからスクリプトを削除するRスクリプトを作成します。この項では、このような関数について説明します。内容は次のとおりです。

- スクリプトを実行する関数の引数

- 埋込みRスクリプトでの自動データベース接続

- ore.doEval関数の使用方法

- ore.tableApply関数の使用方法

- ore.groupApply関数の使用方法

- ore.rowApply関数の使用方法

- ore.indexApply関数の使用方法

- ore.scriptCreate関数およびore.scriptDrop関数の使用方法

スクリプトを実行する関数の引数

Oracle R Enterpriseの埋込みRの実行関数のore.doEval、ore.tableApply、ore.groupApply、ore.rowApplyおよびore.indexApplyには、これらの関数の一部またはすべてに共通の引数があります。一部の関数には、その関数に固有の引数もあります。

この項では、引数について次の各項で説明します。

- 実行するための入力関数

- オプションの引数

- 戻り値の構造

- 入力データ

- パラレル実行

- 固有の引数

関連項目:

- 関数シグネチャおよび関数の引数の詳細は、help(ore.doEval)を呼び出すことで表示されるオンライン・ヘルプを参照してください。

- 引数の使用例は、「ore.doEval関数の使用方法」および埋込みRの実行関数の使用方法に関するその他の項を参照してください。

実行するための入力関数

すべての埋込みRの実行関数には、スクリプトの実行時に適用するための関数が必要です。次の相互に排他的な引数のどちらかを使用して入力関数を指定します。

- FUN

- FUN.NAME

FUN引数は、関数オブジェクトを直接指定された関数としてまたはR変数に割り当てられた関数として使用します。RQADMINロールを持つユーザーのみが、埋込みR関数の呼出し時にFUN引数を使用できます。

FUN.NAME引数には、Rスクリプト・リポジトリに格納されているスクリプトを指定します。格納されたスクリプトには、スクリプトの実行時に適用する関数が含まれます。すべてのOracle R Enterpriseユーザーが、埋込みR関数の呼出し時にFUN.NAME引数を使用できます。

OREmodelsパッケージのOracle R Enterpriseの高度な分析関数であるore.glm、ore.lmおよびore.neuralは、埋込みRの実行フレームワークを内部で使用し、埋込みRの実行関数では使用できません。

オプションの引数

すべての埋込みRの実行関数は、指定が可能または不可能なオプションの引数も取ります。Oracle R Enterpriseは、ユーザー定義のオプションの引数を入力関数に渡します。モデルなどの複合Rオブジェクトを含む入力関数に、任意の数のオプションの引数を渡すことができます。

ore.で始まる引数は、特殊な制御引数です。Oracle R Enterpriseはそれらを入力関数に渡しませんが、かわりに、それらを使用して入力関数の実行前または後に発生することを制御します。次の制御引数がサポートされます。

- ore.connectは、埋込みRの実行関数内でOracle R Enterpriseに自動的に接続するかどうかを制御します。これは、クライアント・セッションと同じ資格証明を指定してore.connectをコールすることと同等です。デフォルト値はFALSEです。

関連項目:
「埋込みRスクリプトでの自動データベース接続」

- ore.dropは入力データを制御します。TRUEを指定した場合、1列のdata.frameがベクターに変換されます。デフォルト値はTRUEです。

- ore.na.omit入力データの欠損値の処理を制御します。TRUEを指定した場合、欠損値を含む行またはベクター要素(ore.drop設定に応じて)が入力データから削除されます。チャンクのすべての行に欠損値がある場合、そのチャンクの入力データは空のdata.frameまたはvectorになります。デフォルト値はFALSEです。

- ore.graphicsは、グラフィカル・ドライバを起動して画像を検索するかどうかを制御します。デフォルト値はTRUEです。

- ore.png.*には、ore.graphicsがTRUEの場合に、pngグラフィック・ドライバの追加引数を指定します。これらの引数のネーミング規則では、png関数の引数にore.png.接頭辞を追加します。たとえば、ore.png.heightを指定すると、引数heightがpng関数に渡されます。設定しない場合は、png関数に標準のデフォルト値が使用されます。

戻り値の構造

すべての埋込みRの実行関数に適用されるもう1つの引数にFUN.VALUEがあります。FUN.VALUE引数がNULLの場合、ore.doEval関数およびore.tableApply関数はore.objectクラス・オブジェクトとしてシリアライズRオブジェクトを返し、ore.groupApply、ore.indexApplyおよびore.rowApplyの各関数はore.listオブジェクトを返します。ただし、data.frameまたはore.frameにFUN.VALUE引数を指定した場合、この関数は、指定したdata.frameオブジェクトまたはore.frameオブジェクトの構造を持つore.frameを返します。

入力データ

ore.doEval関数およびore.indexApply関数は、データベースから自動的にデータを受け取りません。FUN引数またはFUN.NAME引数で指定された関数を単純に実行します。入力関数で必要なすべてのデータは、その関数内で生成されるか、Oracle Database、その他のデータベースまたはフラット・ファイルなどのデータ・ソースから明示的に取得するかのいずれかです。入力関数は、ore.pull関数またはその他の透過層関数を使用して、ファイルまたは表からデータをロードできます。

ore.tableApply、ore.groupApplyおよびore.rowApplyの各関数には、入力データとしてデータベース表が必要です。この表はore.frameで表されます。このデータに、X引数(埋込みRの実行関数の最初の引数)で指定するore.frameを指定します。埋込みRの実行関数は、ore.frameオブジェクトを最初の引数としてユーザー定義の入力関数に渡します。

注意:
ユーザー定義のR関数に渡されたore.frameオブジェクトによって表されるデータは、Oracle Databaseからデータベース・サーバーのRエンジンにコピーされます。Rメモリーの制限が適用されます。データベース・サーバー・マシンに32GBのRAMがあり、データ表が64GBの場合、Oracle R EnterpriseはデータをRエンジンのメモリーにロードできません。

埋込みRの実行関数が渡す、ore.tableApplyを使用して呼び出したユーザー定義のR関数の最初の引数として提供されたore.frameオブジェクトの入力データは、Oracle Databaseからデータベース・サーバーのRエンジンに物理的に移動されます。Rのメモリー制限がここにも適用されることに注意してください。データベース・サーバー・マシンに32GBのRAMがあり、データ表が64GBの場合、Oracle R EnterpriseはデータをRエンジンのメモリーにロードできません。

パラレル実行

ore.groupApply、ore.indexApplyおよびore.rowApplyの各関数は、parallel引数を取ります。この引数には、入力関数の埋込みRの実行で使用するための並列度を指定します。「パラレル実行のサポート」を参照してください。

固有の引数

ore.groupApply、ore.indexApplyおよびore.rowApplyの各関数は、関数に固有の引数を取ります。

ore.groupApply関数はINDEX引数を取り、これには、入力データの行が入力関数での処理のためにパーティショニングされる列の名前を指定します。

ore.indexApply関数はtimes引数を取り、これには、入力関数を実行する回数を指定します。

ore.rowApply関数はrows引数を取り、これには、入力関数の各呼出しに渡す行の数を指定します。

埋込みRスクリプトでの自動データベース接続

埋込みRスクリプトは、Oracle Databaseに自動的に接続できます。

自動接続を有効にすると、次の機能が実行されます。

- 埋込みRスクリプトが自動的にデータベースに接続します。

- 自動接続は、埋込みR SQL関数を起動するセッションと同じ資格証明を持ちます。

- このスクリプトは自律型トランザクション内で実行されます。

- ROracle問合せは自動接続と連携します。

- Oracle R Enterpriseの透過層が埋込みスクリプトで使用可能になります。

- ユーザーおよびサイト全体でのRプロファイルのロードは埋込みRでは無効になっています。
プロファイルのロードは、Oracle R Enterpriseの以前のリリースでサポートされていました。自動接続は、より安全な接続を提供します。

自動接続は、デフォルトでは無効になっています。自動接続は、ore.connect制御引数を使用して有効または無効に指定できます。制御引数については、ore.doEvalに関するRオンライン・ヘルプに記載されています。

自動接続を可能にするため、ROracleが拡張されて、新しいドライバExtDriverとコンストラクタExtprocが追加されました。これは、extprocコンテキストをラップする外部ポインタを渡すことで初期化されます。OraDriverと同様に、ExtDriverはシングルトンです。これらのドライバは、2つの個別のシングルトンで表されるため、セッションで同時に存在できます。この設定によって、次の例に示すように、extproc接続と明示的なOraDriver接続を、同じRスクリプトで機能させることができます。

ore.doEval(function() {
ore.disconnect()
con1 <- dbConnect(Extproc())
res1 <- dbGetQuery(con1, "select * from grade order by name")
con2 <- dbConnect(Oracle(), "scott", "tiger")
res2 <- dbGetQuery(con2, "select * from emp order by empno")
dbDisconnect(con1)
dbDisconnect(con2)
cbind(head(res1)[,1:3], head(res2)[,1:3])
} }, ore.connect = TRUE)

ore.doEval関数の使用方法

ore.doEval関数は、入力関数によって生成されたデータを使用して指定された入力関数を実行します。ore.frameオブジェクトまたはシリアライズRオブジェクトをore.objectオブジェクトとして返します。

関連項目:
「スクリプトを実行する関数の引数」

例6-3では、data.frameオブジェクトを返すfunctionオブジェクトのRandomRedDotsを作成し、これには、引数があり、2列で、100個のランダムの標準値があります。この例では次に、ore.doEval関数を呼び出して、RandomRedDotsオブジェクトを渡します。イメージがクライアントに表示されますが、これはRandomRedDots関数を実行したデータベース・サーバーのRエンジンによって生成されます。

例6-3 ore.doEval関数の使用方法

RandomRedDots <- function(divisor=100){
id<- 1:10
plot(1:100, rnorm(100), pch = 21, bg = "red", cex = 2 )
data.frame(id=id, val=id / divisor)
}
ore.doEval(RandomRedDots)

例6-3のリスト

R> RandomRedDots <- function(divisor=100){
+   id<- 1:10
+   plot(1:100, rnorm(100), pch = 21, bg = "red", cex = 2 )
+   data.frame(id=id, val=id / divisor)
+ }
R> ore.doEval(RandomRedDots)
id  val
1   1 0.01
2   2 0.02
3   3 0.03
4   4 0.04
5   5 0.05
6   6 0.06
7   7 0.07
8   8 0.08
9   9 0.09
10 10 0.10

図6-1 ランダムの赤い点の表示

doEval関数のオプションの引数として入力関数に引数を指定できます。例6-4では、RandomRedDots関数のdivisor引数をオーバーライドするオプションの引数を指定してdoEval関数を呼び出します。

例6-4 オプションの引数を指定したore.doEval関数の使用方法

ore.doEval(RandomRedDots, divisor=50)

例6-4のリスト

R> ore.doEval(RandomRedDots, divisor=50)
id  val
1   1 0.02
2   2 0.04
3   3 0.06
4   4 0.08
5   5 0.10
6   6 0.12
7   7 0.14
8   8 0.16
9   9 0.18
10 10 0.20
# The graph displayed by the plot function is not shown.

入力関数がRスクリプト・リポジトリに格納されている場合は、ore.doEval関数をFUN.NAME引数を指定して呼び出せます。例6-5では、ore.doEval関数を呼び出し、その名前でRスクリプト・リポジトリに追加されたRandomRedDots関数であるmyRandomRedDotsを指定します。結果は変数resに割り当てられます。

RandomRedDots関数の戻り値はdata.frameですが、例6-5では、ore.doEval関数はore.objectオブジェクトを返します。data.frameオブジェクトを取得するために、この例ではore.pullを呼び出して結果をクライアントのRエンジンにプルします。

例6-5 FUN.NAME引数を指定したore.doEval関数の使用方法

res <- ore.doEval(FUN.NAME="myRandomRedDots",divisor=50)
class(res)
res.local <- ore.pull(res)
class(res.local)

例6-5のリスト

R> res <- ore.doEval(FUN.NAME = "myRandomRedDots", divisor = 50)
R> class(res)
[1] "ore.object"
attr(,"package")
[1] "OREembed"
R> res.local <- ore.pull(res)
R> class(res.local)
[1] "data.frame"

doEval関数でore.objectではなくore.frameオブジェクトを返すようにするには、例6-6に示すとおり、引数FUN.VALUEを指定して結果の構造を記述します。

例6-6 FUN.VALUE引数を指定したore.doEval関数の使用方法

res.of <- ore.doEval(FUN.NAME="myRandomRedDots", divisor=50,
FUN.VALUE= data.frame(id=1, val=1))
class(res.of)

例6-6のリスト

R> res.of <- ore.doEval(FUN.NAME="myRandomRedDots", divisor=50,
+                        FUN.VALUE= data.frame(id=1, val=1))
R> class(res.of)
[1] "ore.frame"
attr(,"package")
[1] "OREbase"

入力関数内でOracle Databaseへの接続を確立するには、特別なオプションの引数ore.connectをTRUEに設定します。接続を確立してOracle R Enterpriseパッケージも自動的にロードするために、関数ore.doEvalを呼び出したユーザーの資格証明が使用されます。この機能は、Oracle R Enterpriseの透過層を明示的に使用するか、Oracle R Enterpriseデータストアに対してオブジェクトを保存およびロードするために役立ちます。

例6-7では、例6-3のようにRandomRedDots関数オブジェクトを作成しますが、今回この関数には、データストアの名前を使用する引数を指定します。この例では、myVar変数を作成して、datastore_1という名前のデータストアに保存します。次に、doEval関数を呼び出し、データストアの名前を渡し、ore.connect引数を指定します。

例6-7 ore.connect引数を指定したdoEval関数の使用方法

RandomRedDots <- function(divisor=100, datastore.name="myDatastore"){
id <- 1:10
plot(1:100, rnorm(100), pch = 21, bg = "red", cex = 2 )
ore.load(datastore.name) # contains numeric variable myVar
data.frame(id=id, val=id / divisor, num=myVar)
}
myVar <- 5
ore.save(myVar, name = "datastore_1")
ore.doEval(RandomRedDots, datastore.name="datastore_1", ore.connect=TRUE)

例6-7のリスト

R> RandomRedDots <- function(divisor=100, datastore.name="myDatastore"){
+   id <- 1:10
+   plot(1:100, rnorm(100), pch = 21, bg = "red", cex = 2 )
+   ore.load(datastore.name) # contains numeric variable myVar
+   data.frame(id=id, val=id / divisor, num=myVar)
+ }
R> ore.doEval(RandomRedDots, datastore.name="datastore_1", ore.connect=TRUE)
id  val num
1   1 0.01   5
2   2 0.02   5
3   3 0.03   5
4   4 0.04   5
5   5 0.05   5
6   6 0.06   5
7   7 0.07   5
8   8 0.08   5
9   9 0.09   5
10 10 0.10   5
# The graph displayed by the plot function is not shown.

ore.tableApply関数の使用方法

ore.tableApply関数は、入力データとしてore.frameを指定してRスクリプトを起動します。ore.tableApply関数は、ore.frameを最初の引数としてユーザー定義の入力関数に渡します。ore.tableApply関数は、ore.frameオブジェクトまたはシリアライズRオブジェクトをore.objectオブジェクトとして返します。

関連項目:

- 「スクリプトを実行する関数の引数」

- 「埋込みRの実行で使用するためのサード・パーティのパッケージのインストール」

例6-8では、ore.tableApply関数を使用してirisデータセットにNaive Bayesモデルを構築します。naiveBayes関数はe1071パッケージにあり、クライアントとデータベース・サーバー・マシンの両方のRエンジンにインストールする必要があります。ore.tableApply関数の最初の引数として、ore.push(iris)の呼出しでは一時データベース表およびその表のプロキシであるore.frameが作成されます。2番目の引数は入力関数で、これには引数datがあります。ore.tableApply関数は、ore.frameをdat引数として入力関数に渡します。この入力関数は、ore.tableApply関数がore.objectオブジェクトとして返すモデルを作成します。

例6-8 ore.tableApply関数の使用方法

library(e1071)
mod <- ore.tableApply(
ore.push(iris),
function(dat) {
library(e1071)
dat$Species <- as.factor(dat$Species)
naiveBayes(Species ~ ., dat)
})
class(mod)
mod

例6-8のリスト

R> mod <- ore.tableApply(
+   ore.push(iris),
+   function(dat) {
+     library(e1071)
+     dat$Species <- as.factor(dat$Species)
+     naiveBayes(Species ~ ., dat)
+ })
R> class(mod)
[1] "ore.object"
attr(,"package")
[1] "OREembed"
R> mod

Naive Bayes Classifier for Discrete Predictors

Call:
naiveBayes.default(x = X, y = Y, laplace = laplace)

A-priori probabilities:
Y
setosa versicolor  virginica
0.3333333  0.3333333  0.3333333

Conditional probabilities:
Sepal.Length
Y             [,1]      [,2]
setosa     5.006 0.3524897
versicolor 5.936 0.5161711
virginica  6.588 0.6358796

Sepal.Width
Y             [,1]      [,2]
setosa     3.428 0.3790644
versicolor 2.770 0.3137983
virginica  2.974 0.3224966

Petal.Length
Y             [,1]      [,2]
setosa     1.462 0.1736640
versicolor 4.260 0.4699110
virginica  5.552 0.5518947

Petal.Width
Y             [,1]      [,2]
setosa     0.246 0.1053856
versicolor 1.326 0.1977527
virginica  2.026 0.2746501

ore.groupApply関数の使用方法

ore.groupApply関数は、入力データとしてore.frameを指定してRスクリプトを起動します。ore.groupApply関数は、ore.frameを最初の引数としてユーザー定義の入力関数に渡します。ore.groupApply関数のINDEX引数は、ore.frameの列の名前を指定しますが、これによってOracle Databaseはユーザー定義のR関数による処理のために行をパーティショニングします。ore.groupApply関数は、1つ以上のRエンジンが同じR関数(タスク)をデータの別のパーティションで実行するデータ・パラレル実行を使用できます。

ore.groupApply関数は、ore.listオブジェクトまたはore.frameオブジェクトを返します。

ore.groupApply関数の使用例は、次の各項で説明します。

- 単一列のパーティショニング

- 複数列のパーティショニング

関連項目:

- 「スクリプトを実行する関数の引数」

- 「埋込みRの実行で使用するためのサード・パーティのパッケージのインストール」

単一列のパーティショニング

例6-9は、C50パッケージを使用して、各状態のデータに1つの流動モデルを作成することを目的に、C5.0ディシジョン・ツリー・モデルをC50のchurnデータセットに構築します。この例では、次の操作を実行しています。

- C50パッケージをロードした後に、churnデータセットをロードします。

- ore.create関数を使用して、データベース表およびchurnTrain (data.frameオブジェクト)からプロキシore.frameオブジェクトを作成します。

- CHURN_TRAIN (ore.frameオブジェクト)をore.groupApply関数の最初の引数として指定し、state列をINDEX引数として指定します。ore.groupApply関数は、state列のデータをパーティショニングし、ユーザー定義の関数を各パーティションで呼び出します。

- ユーザー定義の関数を指定します。ユーザー定義の関数の最初の引数は、データ(1つの状態に関連付けられたすべてのデータ)の1つのパーティションを受け取ります。

- ユーザー定義の関数は、次のことを実行します。

- データベースのRエンジンで起動したときに関数で使用できるように、C50パッケージをロードします。

- state列がモデルに含まれないように、data.frameからこの列を削除します。

- ore.frameはファクタを定義しますが、ユーザー定義の関数にロードされたときにファクタが文字列ベクターとして表示されるため、列をファクタに変換します。

- 状態のモデルを構築し、それを返します。

- ore.groupApply関数は、データの各パーティションでユーザー定義の関数を実行した結果を含むリストを返します。この場合は、状態ごとに1つのC5.0モデルです。

- この例では、変数modListを作成しますが、これはore.groupApplyによって返されるore.listオブジェクトを取得します。ore.listオブジェクトには、データの各パーティションでユーザー定義の関数を実行した結果が含まれています。この場合は、状態ごとに1つのC5.0モデルで、各モデルはore.objectオブジェクトとして格納されています。

- ore.pull関数を使用してデータベースからmod.MA変数としてモデルを取得し、そこでsummary関数を呼び出します。mod.MAのクラスはC5.0です。

例6-9 ore.groupApply関数の使用方法

library(C50)
data("churn")

ore.create(churnTrain, "CHURN_TRAIN")

modList <- ore.groupApply(
CHURN_TRAIN,
INDEX=CHURN_TRAIN$state,
function(dat) {
library(C50)
dat$state <- NULL
dat$churn <- as.factor(dat$churn)
dat$area_code <- as.factor(dat$area_code)
dat$international_plan <- as.factor(dat$international_plan)
dat$voice_mail_plan <- as.factor(dat$voice_mail_plan)
C5.0(churn ~ ., data = dat, rules = TRUE)
});
mod.MA <- ore.pull(modList$MA)
summary(mod.MA)

例6-9のリスト

R> library(C50)
R> data(churn)
R>
R> ore.create(churnTrain, "CHURN_TRAIN")
R>
R> modList <- ore.groupApply(
+   CHURN_TRAIN,
+   INDEX=CHURN_TRAIN$state,
+     function(dat) {
+       library(C50)
+       dat$state <- NULL
+       dat$churn <- as.factor(dat$churn)
+       dat$area_code <- as.factor(dat$area_code)
+       dat$international_plan <- as.factor(dat$international_plan)
+       dat$voice_mail_plan <- as.factor(dat$voice_mail_plan)
+       C5.0(churn ~ ., data = dat, rules = TRUE)
+     });
R> mod.MA <- ore.pull(modList$MA)
R> summary(mod.MA)

Call:
C5.0.formula(formula = churn ~ ., data = dat, rules = TRUE)

C5.0 [Release 2.07 GPL Edition]         Thu Feb 13 15:09:10 2014
-------------------------------

Class specified by attribute `outcome'

Read 65 cases (19 attributes) from undefined.data

Rules:

Rule 1: (52/1, lift 1.2)
international_plan = no
total_day_charge <= 43.04
->  class no  [0.963]

Rule 2: (5, lift 5.1)
total_day_charge > 43.04
->  class yes  [0.857]

Rule 3: (6/1, lift 4.4)
area_code in {area_code_408, area_code_415}
international_plan = yes
->  class yes  [0.750]

Default class: no

Evaluation on training data (65 cases):

Rules
----------------
No      Errors

3    2( 3.1%)   <<

(a)   (b)    <-classified as
----  ----
53     1    (a): class no
1    10    (b): class yes

Attribute usage:

89.23% international_plan
87.69% total_day_charge
9.23% area_code

Time: 0.0 secs

複数列のパーティショニング

ore.groupApply関数はINDEX引数に1つの列のみを取りますが、使用する列を連結した新しい列を作成して、この新しい列をINDEX引数に指定できます。

例6-10は、CHURN_TRAINデータセットのデータを使用して、指定したデータのパーティション(voice_mail_plan列およびinternational_plan列)に対するルールを作成するrpartモデルを構築します。この例では、Rのtable関数を使用して各パーティションで予測される行の数を示します。次に、vmp_ip.g1という名前の新しい列を作成するために、必要な2列を一緒にペーストした新しい列を追加します。

この例では次に、ore.scriptDropを呼び出して、Rスクリプト・リポジトリに指定した名前のスクリプトが存在しないことを確認します。その後、ore.scriptCreate関数を使用してmy.rpartFunctionという名前のスクリプトを定義し、それをリポジトリに格納します。格納されたスクリプトでは、Oracle R Enterpriseのデータストア・オブジェクトの命名に使用されるデータ・ソースおよび接頭辞を使用する関数を定義します。my.rpartFunction関数を呼び出すたびに、vmp_ipで特定されるパーティションの1つからデータを取得します。ソース・パーティションの列は定数のため、この関数はそれらをNULLに設定します。文字列ベクターをファクタに変換し、流動を予測するためのモデルを構築し、そこに適切に命名されたデータストアを保存します。この関数は、特定のパーティション列値、流動値の分布およびモデル自身を返すためのリストを作成します。

この例では、次にrpartライブラリをロードし、データストアの接頭辞を設定し、派生列vmp_ipを引数INDEXに対する入力とし、my.rpartFunctionをRスクリプト・リポジトリに格納されているユーザー定義の関数を呼び出すための引数FUN.NAMEの入力として使用して、ore.groupApplyを呼び出します。ore.groupApply関数は、オプションの引数を使用してdatastorePrefix変数をユーザー定義の関数に渡します。この関数は、ユーザー定義の関数の実行時に、オプションの引数ore.connectを使用してデータベースに接続します。ore.groupApply関数は、変数resとしてore.listオブジェクトを返します。

この例では、返されるリストの最初のエントリを表示します。次に、ore.load関数を呼び出して、顧客がボイス・メール・プランと国際プランの両方を持つ場合のモデルをロードします。

例6-10 複数列でデータをパーティションする場合のore.groupApplyの使用方法

library(C50)
data(churn)
ore.drop("CHURN_TRAIN")
ore.create(churnTrain, "CHURN_TRAIN")

table(CHURN_TRAIN$international_plan, CHURN_TRAIN$voice_mail_plan)
CT <- CHURN_TRAIN
CT$vmp_ip <- paste(CT$voice_mail_plan,CT$international_plan,sep="-")
options(width = 80)
head(CT, 3)

ore.scriptDrop("my.rpartFunction")
ore.scriptCreate("my.rpartFunction",
function(dat,datastorePrefix) {
library(rpart)
vmp <- dat[1,"voice_mail_plan"]
ip <- dat[1,"international_plan"]
datastoreName <- paste(datastorePrefix,vmp,ip,sep="_")
dat$voice_mail_plan <- NULL
dat$international_plan <- NULL
dat$state <- as.factor(dat$state)
dat$churn <- as.factor(dat$churn)
dat$area_code <- as.factor(dat$area_code)
mod <- rpart(churn ~ ., data = dat)
ore.save(mod, name=datastoreName, overwrite=TRUE)
list(voice_mail_plan=vmp,
international_plan=ip,
churn.table=table(dat$churn),
rpart.model = mod)
})

library(rpart)
datastorePrefix="my.rpartModel"

res <- ore.groupApply( CT, INDEX=CT$vmp_ip,
FUN.NAME="my.rpartFunction",
datastorePrefix=datastorePrefix,
ore.connect=TRUE)
res[[1]]
ore.load(name=paste(datastorePrefix,"yes","yes",sep="_"))
mod

例6-10のリスト

R> library(C50)
R> data(churn)
R> ore.drop("CHURN_TRAIN")
R> ore.create(churnTrain, "CHURN_TRAIN")
R>
R> table(CHURN_TRAIN$international_plan, CHURN_TRAIN$voice_mail_plan)

no  yes
no  2180  830
yes  231   92
R> CT <- CHURN_TRAIN
R> CT$vmp_ip <- paste(CT$voice_mail_plan,CT$international_plan,sep="-")
R> options(width = 80)
R> head(CT, 3)
state account_length     area_code international_plan voice_mail_plan
1    KS            128 area_code_415                 no             yes
2    OH            107 area_code_415                 no             yes
3    NJ            137 area_code_415                 no              no
number_vmail_messages total_day_minutes total_day_calls total_day_charge
1                    25             265.1             110            45.07
2                    26             161.6             123            27.47
3                     0             243.4             114            41.38
total_eve_minutes total_eve_calls total_eve_charge total_night_minutes
1             197.4              99            16.78               244.7
2             195.5             103            16.62               254.4
3             121.2             110            10.30               162.6
total_night_calls total_night_charge total_intl_minutes total_intl_calls
1                91              11.01               10.0                3
2               103              11.45               13.7                3
3               104               7.32               12.2                5
total_intl_charge number_customer_service_calls churn vmp_ip
1              2.70                             1    no yes-no
2              3.70                             1    no yes-no
3              3.29                             0    no  no-no
R>
R> ore.scriptDrop("my.rpartFunction")
R> ore.scriptCreate("my.rpartFunction",
+   function(dat,datastorePrefix) {
+     library(rpart)
+     vmp <- dat[1,"voice_mail_plan"]
+     ip <- dat[1,"international_plan"]
+     datastoreName <- paste(datastorePrefix,vmp,ip,sep="_")
+     dat$voice_mail_plan <- NULL
+     dat$international_plan <- NULL
+     dat$state <- as.factor(dat$state)
+     dat$churn <- as.factor(dat$churn)
+     dat$area_code <- as.factor(dat$area_code)
+     mod <- rpart(churn ~ ., data = dat)
+     ore.save(mod, name=datastoreName, overwrite=TRUE)
+     list(voice_mail_plan=vmp,
+         international_plan=ip,
+         churn.table=table(dat$churn),
+         rpart.model = mod)
+   })
R>
R> library(rpart)
R> datastorePrefix="my.rpartModel"
R>
R> res <- ore.groupApply( CT, INDEX=CT$vmp_ip,
+       FUN.NAME="my.rpartFunction",
+       datastorePrefix=datastorePrefix,
+       ore.connect=TRUE)
R> res[[1]]
$voice_mail_plan
[1] "no"

$international_plan
[1] "no"

$churn.table

no  yes
1878  302

$rpart.model
n= 2180

node), split, n, loss, yval, (yprob)
* denotes terminal node

1) root 2180 302 no (0.86146789 0.13853211)
2) total_day_minutes< 263.55 2040 192 no (0.90588235 0.09411765)
4) number_customer_service_calls< 3.5 1876 108 no (0.94243070 0.05756930)
8) total_day_minutes< 223.25 1599  44 no (0.97248280 0.02751720) *
9) total_day_minutes>=223.25 277  64 no (0.76895307 0.23104693)
18) total_eve_minutes< 242.35 210  18 no (0.91428571 0.08571429) *
19) total_eve_minutes>=242.35 67  21 yes (0.31343284 0.68656716)
38) total_night_minutes< 174.2 17   4 no (0.76470588 0.23529412) *
39) total_night_minutes>=174.2 50   8 yes (0.16000000 0.84000000) *
5) number_customer_service_calls>=3.5 164  80 yes (0.48780488 0.51219512)
10) total_day_minutes>=160.2 95  22 no (0.76842105 0.23157895)
20) state=AL,AZ,CA,CO,DC,DE,FL,HI,KS,KY,MA,MD,ME,MI,NC,ND,NE,NH,NM,OK,OR,SC,TN,VA,VT,WY 56   2 no (0.96428571 0.03571429) *
21) state=AK,AR,CT,GA,IA,ID,MN,MO,NJ,NV,NY,OH,RI,TX,UT,WA,WV 39  19 yes (0.48717949 0.51282051)
42) total_day_minutes>=182.3 21   5 no (0.76190476 0.23809524) *
43) total_day_minutes< 182.3 18   3 yes (0.16666667 0.83333333) *
11) total_day_minutes< 160.2 69   7 yes (0.10144928 0.89855072) *
3) total_day_minutes>=263.55 140  30 yes (0.21428571 0.78571429)
6) total_eve_minutes< 167.3 29   7 no (0.75862069 0.24137931)
12) state=AK,AR,AZ,CO,CT,FL,HI,IN,KS,LA,MD,ND,NM,NY,OH,UT,WA,WV 21   0 no (1.00000000 0.00000000) *
13) state=IA,MA,MN,PA,SD,TX,WI 8   1 yes (0.12500000 0.87500000) *
7) total_eve_minutes>=167.3 111   8 yes (0.07207207 0.92792793) *

R> ore.load(name=paste(datastorePrefix,"yes","yes",sep="_"))
[1] "mod"
R> mod
n= 92

node), split, n, loss, yval, (yprob)
* denotes terminal node

1) root 92 36 no (0.60869565 0.39130435)
2) total_intl_minutes< 13.1 71 15 no (0.78873239 0.21126761)
4) total_intl_calls>=2.5 60  4 no (0.93333333 0.06666667)
8) state=AK,AR,AZ,CO,CT,DC,DE,FL,GA,HI,ID,IL,IN,KS,MD,MI,MO,MS,MT,NC,ND,NE,NH,NJ,OH,SC,SD,UT,VA,WA,WV,WY 53  0 no (1.00000000 0.00000000) *
9) state=ME,NM,VT,WI 7  3 yes (0.42857143 0.57142857) *
5) total_intl_calls< 2.5 11  0 yes (0.00000000 1.00000000) *
3) total_intl_minutes>=13.1 21  0 yes (0.00000000 1.00000000) *

ore.rowApply関数の使用方法

ore.rowApply関数は、入力データとしてore.frameを指定してRスクリプトを起動します。ore.rowApply関数は、ore.frameを最初の引数としてユーザー定義の入力関数に渡します。ore.rowApply関数に対するrows引数には、ユーザー定義のR関数の呼出しごとに渡す行の数を指定します。最後のチャンクまたは行は、指定した数より少なくなる可能性があります。ore.rowApply関数は、1つ以上のRエンジンが同じR関数(タスク)をデータの別のパーティションで実行するデータ・パラレル実行を使用できます。

ore.rowApply関数は、ore.listオブジェクトまたはore.frameオブジェクトを返します。

関連項目:

- 「スクリプトを実行する関数の引数」

- 「埋込みRの実行で使用するためのサード・パーティのパッケージのインストール」

例6-11では、事前にCRANからダウンロードしてあるe1071パッケージを使用します。また、この例では、例6-8「ore.tableApply関数の使用方法」で作成したNaive Bayeモデルであるmodオブジェクトも使用します。

例6-11では、次の処理を行います。

- パッケージe1071をロードします。

- irisデータセットをIRIS一時表およびore.frameとしてデータベースにプッシュします。

- IRISをIRIS_PREDとしてコピーし、予測を含めるためにPRED列をIRIS_PREDに追加します。

- ore.rowApply関数を呼び出し、IRISのore.frameをユーザー定義のR関数として渡して関数を定義します。

- ユーザー定義の関数は、次のことを実行します。

- Rエンジンまたはデータベース内で稼働するエンジンで使用できるように、パッケージe1071をロードします。

- ore.frameはファクタを定義しますが、ユーザー定義の関数にロードされたときにファクタが文字列ベクターとして表示されるため、Species列をファクタに変換します。

- predictメソッドを起動し、データセットに追加された列に予測が含まれているresオブジェクトを返します。

- この例では、モデルをクライアントのRセッションにプルします。

- IRIS_PREDを引数FUN.VALUEとして渡しますが、この引数にore.rowApply関数が返すオブジェクトの構造を指定します。

- ユーザー定義関数の呼出しごとに渡す行の数を指定します。

- resのクラスを表示し、table関数を呼び出してSpecies列およびresオブジェクトのPRED列を表示します。

例6-11 ore.rowApply関数の使用方法

library(e1071)
IRIS <- ore.push(iris)
IRIS_PRED <- IRIS
IRIS_PRED$PRED <- "A"
res <- ore.rowApply(
IRIS,
function(dat, mod) {
library(e1071)
dat$Species <- as.factor(dat$Species)
dat$PRED <- predict(mod, newdata = dat)
dat
},
mod = ore.pull(mod),
FUN.VALUE = IRIS_PRED,
rows=10)
class(res)
table(res$Species, res$PRED)

例6-11のリスト

R> library(e1071)
R> IRIS <- ore.push(iris)
R> IRIS_PRED <- IRIS
R> IRIS_PRED$PRED <- "A"
R> res <- ore.rowApply(
+   IRIS ,
+   function(dat, mod) {
+     library(e1071)
+     dat$Species <- as.factor(dat$Species)
+     dat$PRED <- predict(mod, newdata = dat)
+     dat
+   },
+   mod = ore.pull(mod),
+   FUN.VALUE = IRIS_PRED,
+   rows=10)
R> class(res)
[1] "ore.frame"
attr(,"package")
[1] "OREbase"
R> table(res$Species, res$PRED)

setosa versicolor virginica
setosa         50          0         0
versicolor      0         47         3
virginica       0          3        47

ore.indexApply関数の使用方法

ore.indexApply関数は、入力関数によって生成されたデータを使用して指定されたユーザー定義の入力関数を実行します。これは、1つ以上のRエンジンが同じまたは異なる計算(タスク)を実行するタスク・パラレル実行をサポートします。ore.indexApply関数に対するtimes引数には、データベース内で入力関数を実行する回数を指定します。必要なすべてのデータは、入力関数内で明示的に生成またはロードされる必要があります。

ore.indexApply関数は、ore.listオブジェクトまたはore.frameオブジェクトを返します。

ore.indexApply関数の使用例は、次の各項で説明します。

- ore.indexApply関数の簡単な使用例

- 列並行の使用例

- シミュレーションの使用例

関連項目:

- 「スクリプトを実行する関数の引数」

- 「埋込みRの実行で使用するためのサード・パーティのパッケージのインストール」

ore.indexApply関数の簡単な使用例

例6-12では、ore.indexApplyを呼び出し、入力関数を並行して5回実行することを指定します。結果のクラスであるore.listを表示した後に、結果を表示します。

例6-12 ore.indexApply関数の使用方法

res <- ore.indexApply(5,
function(index) {
paste("IndexApply:",index)
},
parallel=TRUE)
class(res)
res

R> res <- ore.indexApply(5,
+       function(index) {
+         paste("IndexApply:",index)
+       },
+       parallel=TRUE)
R> class(res)
[1] "ore.list"
attr(,"package")
[1] "OREembed"
R> res
$`1`
[1] "IndexApply: 1"

$`2`
[1] "IndexApply: 2"

$`3`
[1] "IndexApply: 3"

$`4`
[1] "IndexApply: 4"

$`5`
[1] "IndexApply: 5"

列並行の使用例

例6-12では、Rのsummary関数を使用して、irisデータセットの最初の4つの数値列でサマリー統計を並行して計算します。この例では、計算を最終結果に結合します。ore.indexApply関数の最初の引数は4で、これは、並行してまとめる列の数を指定します。ユーザー定義の入力関数は1つの引数indexを取り、これは、まとめる列を指定する1から4の値です。

この例では、summary関数を指定した列で呼び出します。summaryの呼出しでは、列のサマリー統計が含まれている単一の行が返されます。この例では、summary呼出しの結果をdata.frameに変換し、そこに列名を追加します。

次に、ore.indexApply関数に対してFUN.VALUE引数を使用して、関数の結果の構造を定義します。結果はその後、その構造とともにore.frameオブジェクトとして返されます。

例6-13 ore.indexApply関数の使用方法および結果の結合

res <- NULL
res <- ore.indexApply(4,
function(index) {
ss <- summary(iris[, index])
attr.names <- attr(ss, "names")
stats <- data.frame(matrix(ss, 1, length(ss)))
names(stats) <- attr.names
stats$col <- names(iris)[index]
stats
},
FUN.VALUE=data.frame(Min.=numeric(0),
"1st Qu."=numeric(0),
Median=numeric(0),
Mean=numeric(0),
"3rd Qu."=numeric(0),
Max.=numeric(0),
col=character(0)),
parallel=TRUE)
res

例6-13のリスト

R> res <- NULL
R> res <- ore.indexApply(4,
+       function(index) {
+         ss <- summary(iris[,index])
+         attr.names <- attr(ss,"names")
+         stats <- data.frame(matrix(ss,1,length(ss)))
+         names(stats) <- attr.names
+         stats$col <- names(iris)[index]
+         stats
+       },
+       FUN.VALUE=data.frame(Min.=numeric(0),
+         "1st Qu."=numeric(0),
+         Median=numeric(0),
+         Mean=numeric(0),
+         "3rd Qu."=numeric(0),
+         Max.=numeric(0),
+         col=character(0)),
+       parallel=TRUE)
R> res
Min. X1st.Qu. Median  Mean X3rd.Qu. Max.          col
1  2.0      2.8   3.00 3.057      3.3  4.4  Sepal.Width
2  4.3      5.1   5.80 5.843      6.4  7.9 Sepal.Length
3  0.1      0.3   1.30 1.199      1.8  2.5  Petal.Width
4  1.0      1.6   4.35 3.758      5.1  6.9 Petal.Length
Warning message:
ORE object has no unique key - using random order

シミュレーションの使用例

ore.indexApply関数をシミュレーションで使用しすることで、Oracle Exadataデータベース・マシンなどの高パフォーマンスのコンピューティング・ハードウェアを利用できます。例6-14は、ランダムな正規分布の複数のサンプルを使用してサマリー統計の分布を比較します。各シミュレーションは、データベースの別個のRエンジンで、データベースで許可された並列度まで並列に実行されます。

例6-14では、サンプル・サイズの変数、乱数値の平均および標準偏差および実行するシミュレーションの数を定義します。この例では、num.simulationsをore.indexApply関数の最初の引数として指定します。ore.indexApply関数は、num.simulationsをindex引数としてユーザー定義の関数に渡します。この入力関数はその後、各入力関数の呼出しで異なる乱数値のセットが生成されるように、索引に基づいて乱数シードを設定します。

次に、入力関数は、rnorm関数を使用してsample.sizeランダムな標準値を生成します。乱数のベクターでsummary関数を呼び出し、返される結果としてdata.frameを準備します。ore.indexApply関数には、シミュレーションの結合された結果を構成するore.frameを返すように、FUN.VALUE引数を指定します。res変数は、ore.indexApply関数によって返されるore.frameを取得します。

サンプルの分布を取得するために、この例では、ore.pull関数を使用した結果であるdata.frameでboxplot関数を呼び出し、resから選択した列をクライアントに渡します。

例6-14 シミュレーションでのore.indexApply関数の使用方法

res <- NULL
sample.size = 1000
mean.val = 100
std.dev.val = 10
num.simulations = 1000

res <- ore.indexApply(num.simulations,
function(index, sample.size=1000, mean=0, std.dev=1) {
set.seed(index)
x <- rnorm(sample.size, mean, std.dev)
ss <- summary(x)
attr.names <- attr(ss,"names")
stats <- data.frame(matrix(ss,1,length(ss)))
names(stats) <- attr.names
stats$index <- index
stats
},
FUN.VALUE=data.frame(Min.=numeric(0),
"1st Qu."=numeric(0),
Median=numeric(0),
Mean=numeric(0),
"3rd Qu."=numeric(0),
Max.=numeric(0),
index=numeric(0)),
parallel=TRUE,
sample.size=sample.size,
mean=mean.val, std.dev=std.dev.val)
options("ore.warn.order" = FALSE)
head(res, 3)
tail(res, 3)
boxplot(ore.pull(res[,1:6]),
main=sprintf("Boxplot of %d rnorm samples size %d, mean=%d, sd=%d",
num.simulations, sample.size, mean.val, std.dev.val))

例6-14のリスト

R> res <- ore.indexApply(num.simulations,
+       function(index, sample.size=1000, mean=0, std.dev=1) {
+         set.seed(index)
+         x <- rnorm(sample.size, mean, std.dev)
+         ss <- summary(x)
+         attr.names <- attr(ss,"names")
+         stats <- data.frame(matrix(ss,1,length(ss)))
+         names(stats) <- attr.names
+         stats$index <- index
+         stats
+       },
+       FUN.VALUE=data.frame(Min.=numeric(0),
+         "1st Qu."=numeric(0),
+         Median=numeric(0),
+         Mean=numeric(0),
+         "3rd Qu."=numeric(0),
+         Max.=numeric(0),
+         index=numeric(0)),
+       parallel=TRUE,
+       sample.size=sample.size,
+       mean=mean.val, std.dev=std.dev.val)
R> options("ore.warn.order" = FALSE)
R> head(res, 3)
Min. X1st.Qu. Median   Mean X3rd.Qu.  Max. index
1 67.56    93.11  99.42  99.30    105.8 128.0   847
2 67.73    94.19  99.86 100.10    106.3 130.7   258
3 65.58    93.15  99.78  99.82    106.2 134.3   264
R> tail(res, 3)
Min. X1st.Qu. Median   Mean X3rd.Qu.  Max. index
1 65.02    93.44  100.2 100.20    106.9 134.0     5
2 71.60    93.34   99.6  99.66    106.4 131.7     4
3 69.44    93.15  100.3 100.10    106.8 135.2     3
R> boxplot(ore.pull(res[,1:6]),
+   main=sprintf("Boxplot of %d rnorm samples size %d, mean=%d, sd=%d",
+                num.simulations, sample.size, mean.val, std.dev.val))

図6-2 例6-14でのboxplot関数の表示

ore.scriptCreate関数およびore.scriptDrop関数の使用方法

ore.scriptCreate関数は、Oracle DatabaseのRスクリプト・リポジトリにスクリプトを作成します。埋込みRの実行関数は、FUN.NAME引数とともに指定することでこのリポジトリのスクリプトを使用できます。Rスクリプト・リポジトリのスクリプトは、Oracle R Enterpriseの埋込みRの実行用のSQLインタフェースを介しても使用できます。

ore.scriptDrop関数は、指定したRスクリプトをRスクリプト・リポジトリから削除します。

注意:
ore.scriptCreate関数またはore.scriptDrop関数を呼び出すには、RQADMINロールが必要です。

ore.scriptCreateおよびore.scriptDropの両方の関数は、成功した場合は非表示のNULLを返し、スクリプトの作成または削除が成功しなかった場合はエラーを返します。

例6-15では、スクリプトを作成し、それをRスクリプト・リポジトリに格納します。スクリプトのユーザー定義の関数は線形モデルを作成します。この例では、irisデータセットをデータベースにプッシュします。その後、ore.tableApply関数を呼び出し、この格納されたスクリプトにFUN.NAME引数を指定します。例では次に、リポジトリからスクリプトを削除します。

例6-15 ore.scriptCreate関数およびore.scriptDrop関数の使用方法

ore.scriptCreate("MYLM",function(data, formula, ...) lm(formula, data, ...))
IRIS <- ore.push(iris)
ore.tableApply(IRIS[1:4], FUN.NAME = "MYLM", formula = Sepal.Length ~ .)
ore.scriptDrop("MYLM")

例6-15のリスト

R> ore.scriptCreate("MYLM",function(data, formula, ...) lm(formula, data, ...))
R> IRIS <- ore.push(iris)
R> ore.tableApply(IRIS[1:4], FUN.NAME = "MYLM", formula = Sepal.Length ~ .)

Call:
lm(formula = formula, data = data)

Coefficients:
(Intercept)   Sepal.Width  Petal.Length   Petal.Width
1.8560        0.6508        0.7091       -0.5565
R> ore.scriptDrop("MYLM")

関連項目:
例6-10

埋込みRの実行用のSQLインタフェース

Oracle R Enterpriseの埋込みRの実行用のSQLインタフェースでは、本番データベースのアプリケーションでRスクリプトを実行できます。

SQLインタフェースで使用する関数は、データベースRリポジトリに格納し、SQLのAPI関数の名前で参照する必要があります。リポジトリにスクリプトを追加する方法、リポジトリからスクリプトを削除する方法、およびリポジトリ内のスクリプトの一覧を表示して使用する方法については、「SQLスクリプトの登録および管理」を参照してください。

SQL関数についての説明は、「Oracle R EnterpriseのSQL関数について」を参照してください。

この項では、SQLインタフェースについて、次の各項で説明します。

- SQLスクリプトの登録および管理

- Oracle R EnterpriseのSQL関数について

- rqGroupEval関数の使用方法

- データストアでのSQL関数およびオブジェクトの使用方法

- SQLでのデータストア管理

SQLスクリプトの登録および管理

埋込みRの実行用のSQLインタフェースで使用するR関数は、データベースのRスクリプト・リポジトリに格納し、SQLのAPI関数の名前で参照する必要があります。セキュリティ上の理由により、最初にシステムで一意の名前でRスクリプトを登録し、SQLインタフェース表関数へのコールで実際のスクリプトのかわりに新しい名前を使用する必要があります。

管理用の関数sys.rqScriptCreateおよびsys.rqScriptDropは、スクリプトを作成および削除します。sys.rq_scriptsビューによって、作成したスクリプトをリストおよび使用できます。

スクリプトの作成または削除には、「スクリプトのセキュリティに関する考慮事項」で説明するRQADMINロールが必要です。

sys.rqScriptCreateを使用する場合は、関数文字列の対応するR閉包を指定する必要があります。

例6-16に、Rスクリプトの登録および使用を示します。

例6-16 Rスクリプトの登録および使用方法

begin
sys.rqScriptCreate('tmrqfun2',
'function() {
ID <- 1:10
res <- data.frame(ID = ID, RES = ID / 100)
res
}');
end;
/

select *
from table(rqEval(
NULL,
'select 1 id, 1 res from dual',
'tmrqfun2'));

begin
sys.rqScriptDrop('tmrqfun2');
end;
/

Oracle R EnterpriseのSQL関数について

Oracle R EnterpriseのSQL関数を呼び出すと、データベースの並列性設定に基づいて、1つ以上のRエンジンがデータベースで起動されます。データベースでのRスクリプトの実行を有効化するために、Oracle R Enterpriseでは、ore.doEval、ore.tableApply、ore.groupApplyおよびore.rowApplyの各関数のSQLバリアントを提供しています。これらのR関数については、「埋込みRの実行用のRインタフェース」で説明しています。

埋込みRの実行用のSQL関数は次のとおりです。

- rqTableEval

- rqEval

- rqRowEval

- rqGroupEval

rqGroupEval関数には追加のSQL指定が必要で、ここでは、指定された列の値に従ってデータをパーティショニングし、各パーティションでRスクリプトを起動する仮想関数として提供されます。詳細は、「rqGroupEval関数の使用方法」を参照してください。

また、「SQLでのデータストア管理」で説明するように、これらの関数をデータストア内のオブジェクトとともに使用できます。

rqEval、rqTableEval、rqGroupEvalおよびrqRowEvalの各関数は、次のような類似した構文を使用します。

rq*Eval(
cursor(select * from table-1),
cursor(select * from table-2),
'select <column list> from table-3 t',
<grouping col-name from table-1 or num_rows>,
<R closure name of registered-R-code>
)

SQL関数のコンポーネントは次のとおりです。

- 最初のカーソルは入力カーソルで、入力は、4番目の引数に記述されているR閉包に、表全体、グループまたはN行として一度に渡されます。
rqEval関数には、このカーソルの引数はありません。

- 2番目のカーソルはパラメータ・カーソルです。1行のスカラー値(文字列、数値またはその両方)を渡すことができます。たとえば、モデルの名前と、モデル設定のいくつかの数値のスカラー値を渡すことができます。

- 問合せによって、出力表の定義が指定されます。出力は「SELECT文」、「XML」または「PNG」にすることができます。

- grouping col-nameはrqGroupEvalに適用され、グループ化列の名前を指定します。

- num_rowsはrqRowEvalに適用され、関数に一度に渡す行の数を指定します。

- <R closure name of registered-R-code>は、実行するR関数の登録済バージョンです。詳細は、「SQLスクリプトの登録および管理」を参照してください。

すべてのSQL関数の戻り値は、次のいずれかの値を示します。

- SELECT文に指定された表のシグネチャ。rq関数からの結果を表として返します。

- XML: 1つのXML文字列で構造化イメージとグラフ・イメージの両方を含むCLOBとして返します。最初に構造化されたコンポーネントが提供され、次にbase 64でエンコードされたイメージのpng表示が続きます。

- PNG: png形式でグラフ・イメージを含むBLOBとして返します。

rqEval、rqTableEval、rqGroupEvalおよびrqRowEvalの各関数には、Rスクリプト・リポジトリ内に格納された名前でRスクリプトを指定する必要があります。sys.rq_scriptsビューでは、登録されたスクリプトのリストが提供されます。

次の例は、これらの関数の使用方法を示しています。

- この例では、表fishのすべての行を、他の引数を取らず、すべての入力データおよび値のROWSUMを含むoutputを生成するR関数への入力として使用します。
このR関数のparam引数はオプションであることに注意してください。

begin
sys.rqScriptCreate('tmrqfun2',
'function(x, param) {
dat <- data.frame(x, stringsAsFactors=F)
cbind(dat, ROWSUM = apply(dat,1,sum)+10)
}');
end;
/

select * from table(rqTableEval(
cursor(select * from fish),
NULL,
'select t.*, 1 rowsum from fish t',
'tmrqfun2' ));

begin
sys.rqScriptDrop('tmrqfun2');
end;
/

- この例は、表fishからR関数に、一度にn=1(4番目のパラメータ)行を渡す方法を示しています。この関数にパラメータは必要ありません。この関数はROWSUMを生成して、出力のfishに別の列として追加します。

begin
sys.rqScriptCreate('tmrqfun2',
'function(x, param) {
dat <- data.frame(x, stringsAsFactors=F)
cbind(dat, ROWSUM = apply(dat,1,sum)+10)
}');
end;
/

select * from table(rqRowEval(
cursor(select * from fish),
NULL,
'select t.*, 1 rowsum from fish t',
1,
'tmrqfun2' ));

begin
sys.rqScriptDrop('tmrqfun2');
end;
/

rqGroupEval関数の使用方法

rqGroupEval関数は、グループ化列によってパーティショニングされたデータ上でRスクリプトを呼び出します。rqGroupEval関数では、次のように、2つのPL/SQLオブジェクトを作成する必要があります。

- 返される結果の型を指定するPL/SQLパッケージ。

- パッケージの戻り値を取り、その戻り値とPIPELINED_PARALLEL_ENABLEセットを使用してデータをパーティショニングする列を示す関数。

ONTIME_Sは、飛行機の到着についての情報を格納した表であるとします。このデータ・カーソルはすべてのデータを使用しますが、PL/SQLレコードを使用して一部の列を使用するカーソルを定義することもできます。次に、特定のデータ・カーソルに対して使用する必要のあるグループ化列と同じ数のPL/SQL表関数を定義する必要があります。

CREATE PACKAGE ontimePkg AS
TYPE cur IS REF CURSOR RETURN ontime_s%ROWTYPE;
END ontimePkg;
/

CREATE FUNCTION ontimeGroupEval(
inp_cur  ontimePkg.cur,
par_cur  SYS_REFCURSOR,
out_qry  VARCHAR2,
grp_col  VARCHAR2,
exp_txt  CLOB)
RETURN SYS.AnyDataSet
PIPELINED PARALLEL_ENABLE (PARTITION inp_cur BY HASH (month))
CLUSTER inp_cur BY (month)
USING rqGroupEvalImpl;
/

この時点では、1つのグループ化列のみがサポートされています。複数の列がある場合、それらの列を1つの列に結合して、その新しい列をグループ化列として使用します。PARALLEL_ENABLE句はオプションですが、CLUSTER BY句はオプションではありません。

データストアでのSQL関数およびオブジェクトの使用方法

埋込みRの実行用のSQL関数では、データストアに保存したシリアライズRオブジェクトをパラメータ・カーソルで使用できます。シリアライズRオブジェクトのオブジェクト名およびデータストア名を、パラメータ・カーソル内のR関数のパラメータ名に関連付けます。

例6-17に、rqTableEval関数の使用方法およびカーソルでのデータストアの指定方法を示します。この例では、ontime_modelという名前のデータストアを使用して、このデータストアからlm.modモデル・オブジェクトを取得します。例では、埋込みRの実行を使用して、スコアリング用にSQLでモデルを使用します。

例6-17 rqTableEvalの使用方法およびデータストアの指定

begin
sys.rqScriptCreate('tmrqmodelscore',
'function(dat, in.dsname, in.objname) {
ore.load(name=in.dsname, list=in.objname)
mod <- get(in.objname)
prd <- predict(mod, newdata=dat)
prd[as.integer(rownames(prd))] <- prd
res <- cbind(dat, PRED = prd)
res
}');
end;
/ -- score model

select * from table(rqTableEval(
cursor(select ARRDELAY, DISTANCE, DEPDELAY from ontime_s
where year = 2003 and month = 5 and dayofmonth = 2),
cursor(select 'ontime_model' as "in.dsname",
'lm.mod' as "in.objname", 1 as "ore.connect" from dual),
'select ARRDELAY, DISTANCE, DEPDELAY, 1 PRED from ontime_s',
'tmrqmodelscore'))
order by 1, 2, 3;

SQLでのデータストア管理

Oracle R Enterpriseは、SQLでの基本的なデータストア管理機能を提供します。基本的なデータストア管理には、表示、検索および削除があります。次の関数およびビューを提供します。

- rqDropDataStoreは、データストアおよびデータストア内のすべてのオブジェクトを削除します。
構文: rqDropDataStore('<ds_name>')。ここで、<ds_name>は削除するデータストアの名前です。

次の例では、現行のユーザーのスキーマからデータストアds_modelを削除します。

rqDropDataStore('ds_model')

- rquser_DataStoreListは、現行のユーザーのスキーマにあるすべてのデータストアの、データストアレベルの情報が含まれるビューです。この情報は、データストア名、オブジェクト数、サイズ、作成日および説明で構成されます。
次の例は、このビューの使用方法を示しています。

select * from rquser_DataStoreList;
select dsname, nobj, dssize from rquser_datastorelist where dsname = 'ds_1';

- rquser_DataStoreContentsは、現行のユーザーのスキーマにあるすべてのデータストアの、オブジェクトレベルの情報が含まれるビューです。この情報は、オブジェクト名、サイズ、クラス、長さ、行および列の数で構成されます。
この例は、データストアds_1の内容をリストします。

select * from rquser_DataStoreContents where dsname = 'ds_1';

A Oracle R EnterpriseでサポートされるR演算子およびR関数

Oracle R Enterpriseパッケージでは、Oracle R Enterpriseオブジェクトで使用できる多数のR演算子およびR関数がサポートされています。この付録では、Oracle R EnterpriseがサポートするR演算子およびR関数をリストします。

「Oracle R Enterpriseの例」で説明するOracle R Enterpriseのサンプル・プログラムには、Oracle R Enterpriseデータ型でこれらの関数の各カテゴリを使用した例がいくつか含まれています。

このリストの関数のみを使用するように制限されているわけではありません。必要とする特定の関数がOracle R Enterpriseでサポートされていない場合は、最初にore.pullを使用してデータベースからRエンジン・メモリーにデータをプルして、メモリー内Rオブジェクトを作成してから、任意のR関数を使用できます。

次の演算子および関数がサポートされています。これらの演算子および関数の構文およびセマンティクスは、Rのドキュメントを参照してください。これらのアイテムの構文およびセマンティクスは、対応するデータベースのマップされたデータ型(Oracle R Enterpriseデータ型とも呼ぶ)に使用する場合も変わりません。Oracle R Enterpriseデータ型のリストは、「Rのデータ型およびクラスの透過層サポート」を参照してください。

- 数学的変換: abs、sign、sqrt、ceiling、floor、trunc、cummax、cummin、cumprod、cumsum、log、loglo、log10、log2、log1p、acos、acosh、asin、asinh、atan、atanh、exp、expm1、cos、cosh、sin、sinh、tan、atan2、tanh、gamma、lgamma、digamma、trigamma、factorial、lfactorial、round、signif、pmin、pmax、zapsmall、rank、diff、besselI、besselJ、besselK、besselY

- 基本統計: mean、summary、min、max、sum、any、all、median、range、IQR、fivenum、mad、quantile、sd、var、table、tabulate、rowSums、colSums、rowMeans、colMeans、cor、cov

- 算術演算子: +、-、*、/、^、%%、%/%

- 比較演算子: ==、>、<、!=、<=、>=

- 論理演算子: &、|、xor

- 集合演算子: unique、%in%、subset

- 文字列演算: tolower、toupper、casefold、toString、chartr、sub、gsub、substr、substring、paste、nchar、grepl

- データ・フレームの結合: cbind、rbind、merge

- ベクトルの結合: append

- ベクトルの作成: ifelse

- サブセットの選択: [、[[、$、head、tail、window、subset、Filter、na.omit、na.exclude、complete.cases

- サブセットの置換: [<-、[[<-、$<-

- データの再編成: split、unlist

- データ処理: eval、with、within、transform

- applyのバリアント: tapply、aggregate、by

- 特別な値のチェック: is.na、is.finite、is.infinite、is.nan

- メタデータ関数: nrow、NROW、ncol、NCOL、nlevels、names、names<-、row、col、dimnames、dimnames<-、dim、length、row.names、row.names<-、rownames、rownames<-、colnames、levels、reorder

- グラフィック: arrows、boxplot、cdplot、co.intervals、coplot、hist、identify、lines、matlines、matplot、matpoints、pairs、plot、points、polygon、polypath、rug、segments、smoothScatter、sunflowerplot、symbols、text、xspline、xy.coords

- 変換関数: as.logical、as.integer、as.numeric、as.character、as.vector、as.factor、as.data.frame

- 型チェック関数: is.logical、is.integer、is.numeric、is.character、is.vector、is.factor、is.data.frame

- 文字の操作: nchar、tolower、toupper、casefold、chartr、sub、gsub、substr

- その他のore.frame関数: data.frame、max.col、scale

- 仮説検定: binom.test、chisq.test、ks.test、prop.test、t.test、var.test、wilcox.test

- 各種分布: 密度、累積分布、および標準分布のクォンタイル関数

- ore.matrix関数: show、is.matrix、as.matrix、%*% (マトリクスの乗算)、t、crossprod (マトリクスのクロス積)、tcrossprod (BをA回転置したマトリクスのクロス積)、solve (反転)、backsolve、forwardsolve、すべての適切な算術関数(abs、signなど)、summary (max、min、allなど)、mean

索引
A  C  D  E  F  G  H  I  K  L  M  N  O  P  Q  R  S  T  U  V  W

A

アクセッサ関数, 3.1.9

集計関数, 1.4.1, 1.4.1, 3.1.5

データの集計, 3.1.5

集計関数, 3.1.9

Aprioriアルゴリズム, 4.2.2

arima関数, 3.1.9

as.Date関数, 3.1.9

as.difftime関数, 3.1.9, 3.1.9

as.integer関数, 3.1.9

as.oreクラス, 3.1.9

as.ore関数, 1.4.2.4

as.ore.character関数, 1.4.2.4, 3.1.9

as.ore.date関数, 3.1.9

相関モデル, 4.2.2

スキーマのアタッチ, 2.2.1.4

属性評価モデル, 4.2.3

C

クラスの継承, 1.4.1

クラス・タイプの強制変換, 1.4.2.4

列

派生, 3.1.6

パーティショニング, 6.5.5.2

データの結合, 3.1.4 Comprehensive R Archive Network

「CRANパッケージ」を参照

Rセッションの接続, 2.1 接続タイプ, 2.1.1.1 接続, 指定, 2.1.1.1 CRANパッケージ, 1.2, 3.1.1, 3.3, 6.3, 6.4 表の作成, 2.2.4 プロキシ・オブジェクトの作成, 2.2.1.1

D

データ

分布の分析, 3.2.10

探索, 3.2

索引付け, 3.1.3

結合, 3.1.4

パーティショニング, 3.1.8

準備, 1.2, 3.1.1

ランキング, 3.2.7

サンプリング, 3.1.7

スコアリング, 1.2

選択, 3.1.2

ソート, 3.2.8

サマリー, 3.1.5, 3.2.9

変換, 3.1.6

データ型

別のタイプへの強制変換, 3.1.9

データストア

概要, 2.2.5.2

削除, 2.2.5.6

情報の取得, 2.2.5.4

埋込みRの実行, 2.2.5.7, 6.6.4

オブジェクトのリストア, 2.2.5.5

オブジェクトの保存, 2.2.5, 2.2.5.3

日付および時間オブジェクト, 3.1.9 ディシジョン・ツリー・アルゴリズム, 4.2.4 ディシジョン・ツリー・モデル, 4.2.4 demo関数, 1.7.2 デモ, 1.7 スキーマのデタッチ, 2.2.1.4 diff関数, 3.1.9, 3.1.9 do.call関数, 3.1.7, 3.1.7 表の削除, 2.2.4

E

簡易接続文字列, 指定, 2.1.2, 2.1.2

埋込みRの実行, 1.2

概要, 6.1

API, 6.1.2

パラレル実行, 6.3, 6.5.1.5

Rインタフェース, 6.5

セキュリティ, 6.2, 6.6.1

SQLインタフェース, 6.6

スクリプト例, 1.7 探索的データ分析

例のデータセット, 3.2.2

指数平滑化モデル, 3.2.6

F

データのフィルタ処理, 2.2.3

forecastパッケージ, 3.2.6

データのフォーマット, 3.1.6

G

一般化線形モデル, 4.1.4, 4.2.5

glm関数, 4.1.4

グローバル・オプション, 1.6, 2.2.2.2

ore.na.extract, 1.6

ore.parallel, 1.6

ore.sep, 1.6

ore.trace, 1.6

ore.warn.order, 1.6

H

Hadoopクラスタ, 2.1.1.1

HIVE接続タイプ, 2.1.1.1

I

データの索引付け, 3.1.3

install.packages関数, 3.3

IRLSアルゴリズム, 4.1.4

is.null関数, 2.2.2.1

is.ore.connected関数, 2.1.1.1

K

鍵

順序付け, 2.2.2.3

k-Meansモデル, 4.2.6 kyphosisデータセット, 4.1.4

L

lapply関数, 3.1.7

最小二乗回帰, 4.1.3

ライブラリ関数, 3.3

線形回帰モデル, 4.1.3

load関数, 2.2.5.1

ローカル・ホスト, 指定, 2.1.2

longleyデータセット, 4.1.2

M

マップ/リデュース処理, 4.1.4

max関数, 3.1.9

min関数, 3.1.9

最小記述長アルゴリズム, 4.2.3

モデル, 4.1.5

相関, 4.2.2

属性評価, 4.2.3

ディシジョン・ツリー, 4.2.4

一般化線形, 4.1.4, 4.2.5

k-Means, 4.2.6

線形回帰, 4.1.3

Naive Bayes, 4.2.7

Non-Negative Matrix Factorization, 4.2.8

Oracle Data Mining, 4.2

直交パーティショニング・クラスタ, 4.2.9

パラメータ的, 4.2.5

予測, 5

サポート・ベクター・マシン, 4.2.10

N

Naive Bayesモデル, 4.2.7

ネーミング規則, 1.4.2.3

NARROWデータセット, 3.2.2

ニューラル・ネットワーク・モデル, 4, 4.1.5

NMFモデル, 4.2.8

O

O-Clusterモデル, 4.2.9

オープン・ソースRパッケージ, 3.3, 6.3

Oracle Advanced Analytics, 1.1

ORACLE接続タイプ, 2.1.1.1

Oracle Data Miningモデル, 4, 4.2

Oracle R Advanced Analytics for Hadoop, 2.1.1.1

Oracleウォレット, 2.1.1.1

ore.frameオブジェクトの順序付け, 1.4.2.2, 2.2.2

ore.attach関数, 2.2.1.1, 2.2.1.4

OREbaseパッケージ, 1.3, 1.4.1

ore.characterオブジェクト, 3.1.9

ore.connect関数, 2.1.1.1, 2.1.1.1

ore.corr関数, 3.2.1, 3.2.3

ore.create関数, 2.2.4

ore.crosstab関数, 3.2.1, 3.2.4

ore.datastore関数, 2.2.5.1, 2.2.5.4

ore.datastoreSummary関数, 2.2.5.1, 2.2.5.4

ore.dateオブジェクト, 3.1.9

ore.datetimeオブジェクト, 3.1.9

ore.delete関数, 2.2.5.1, 2.2.5.6

ore.detach関数, 2.2.1.4

ore.disconnect関数, 2.1.1.1, 2.1.1.2

OREdmパッケージ, 2.2.5.1, 4.2

ore.doEval関数, 6.5.3

ore.drop関数, 2.2.4

OREedaパッケージ, 3.2.1, 3.2.1

ore.esm関数, 3.2.1, 3.2.6

ore.exists関数, 2.2.1.1

ore.frameオブジェクト

概要, 1.4.2.2

表のプロキシ, 2.2.1.1

列のネーミング規則, 1.4.2.3

順序付け, 1.4.2.2

data.frameのサブクラス, 1.4.1

ore.freq関数, 3.2.1, 3.2.5 ore.get関数, 2.2.1.3 ore.glm関数, 4.1.1, 4.1.4 OREgraphicsパッケージ, 1.4.1 ore.groupApply関数, 3.1.8, 6.5.5 ore.hour関数, 3.1.9 ore.indexApply関数, 6.5.7 ore.integerオブジェクト, 3.1.9 ore.lazyLoad関数, 2.2.5.1 ore.listクラス, 2.2.3 ore.lm関数, 4.1.1, 4.1.3 ore.load関数, 2.2.5.1, 2.2.5.5 ore.logicalクラス, 3.1.9 ore.ls関数, 2.2.1.1 ore.mday関数, 3.1.9 ore.minute関数, 3.1.9 OREmodelsパッケージ, 4.1 ore.month関数, 3.1.9 ore.na.extractグローバル・オプション, 1.6 ore.neural関数, 4.1.1, 4.1.5 ore.odmAI関数, 4.2.3 ore.odmAssocRules関数, 4.2.2 ore.odmDT関数, 4.2.4 ore.odmGLM関数, 4.2.5 ore.odmKM関数, 4.2.6 ore.odmNB関数, 4.2.7 ore.odmNMF関数, 4.2.8 ore.odmOC関数, 4.2.9 ore.odmSVM関数, 4.2.10 ore.parallelグローバル・オプション, 1.6 ore.predict関数, 5 OREpredictパッケージ, 5 ore.pull関数, 1.4.2.4, 2.2.3, 3.1.9 ore.push関数, 1.4.2.4, 2.2.3, 4.1.3 ore.rank関数, 3.2.1, 3.2.7 ore.rm関数, 2.2.1.1, 2.2.1.1 ore.rollmean関数, 3.1.9 ore.rollsd関数, 3.1.9 ore.rowApply関数, 6.5.6 ore.save関数, 2.2.5.1, 2.2.5.1, 2.2.5.2, 2.2.5.3 ore.scriptCreate関数, 6.5.8 ore.scriptDrop関数, 6.5.8 ore.second関数, 3.1.9 ore.sepグローバル・オプション, 1.6, 2.2.2.2 ore.sort関数, 3.2.1, 3.2.8 OREstatsパッケージ, 1.4.1 ore.stepwise関数, 4.1.1, 4.1.3 ore.summary関数, 3.2.1, 3.2.9 ore.sync関数, 2.2.1.1, 2.2.1.1, 2.2.1.2, 2.2.1.4 ore.tableApply関数, 6.5.4 ore.traceグローバル・オプション, 1.6 ore.univariate関数, 3.2.1, 3.2.10 ore.warn.orderグローバル・オプション, 1.6, 2.2.2.2 ore.year関数, 3.1.9

P

パッケージ

予測, 3.2.6

Oracle R Enterprise, 1.3

ORE, 1.7.2

OREbase, 1.4.1

OREdm, 2.2.5.1, 4.2

OREeda, 3.2.1

OREgraphics, 1.4.1

OREmodels, 4.1

OREpredict, 5

OREstats, 1.4.1

rpart, 4.1.4

サード・パーティ, 3.3, 6.4

パラレル実行, 6.3, 6.5.1.5 パラメトリック・モデル, 4.2.5 オブジェクトの永続化, 2.2.5.1 データの準備, 1.2

時系列, 3.1.9

主キー

順序付け, 2.2.2.3

プロキシ・オブジェクト

データベース表, 2.2.1.1, 2.2.1.1

Q

quantile関数, 3.1.9

R

Rスクリプト・リポジトリ, 6.6.1

range関数, 3.1.9

rbind関数, 3.1.7, 3.1.7

回帰モデル, 4

プロキシ・オブジェクトの削除, 2.2.1.1

行名

順序付け, 2.2.2.4

rpartパッケージ, 4.1.4 RQADMINロール, 6.2 rqDataStoreContents関数, 6.6.5 rqDataStoreListビュー, 6.6.5 rqDropDataStore関数, 6.6.5 rqEval関数, 6.6.2 rqGroupEval関数, 6.6.2, 6.6.3 rqRowEval関数, 6.6.2 rqTableEval関数, 6.6.2

S

sample関数, 3.1.7, 3.1.7, 3.1.7, 3.1.8

サンプル・プログラム, 1.7

サンプリング

クラスタ, 3.1.7

データベース内データ, 3.1.7

割当て, 3.1.7

層別, 3.1.7

save関数, 2.2.5.1 オブジェクトの保存, 2.2.5 スキーマ

アタッチ, 2.2.1.4

デフォルト, 2.2.1.4

デタッチ, 2.2.1.4

データのスコアリング, 1.2 スクリプト

埋込みRの実行, 6.1

例, 1.7

データベースでの実行, 1.2

検索パス

環境の追加, 2.2.1.4

スキーマの削除, 2.2.1.4

埋込みRの実行スクリプトのセキュリティ, 6.2, 6.6.1 seq関数, 3.1.7, 3.1.9 サービス名, 指定, 2.1.2 sort関数, 3.1.9 埋込みRの実行用のSQL関数, 6.6.2 ステップワイズ最小二乗回帰, 4.1.3 summary関数, 4.1.4 サポートされるR演算子およびR関数, A SVMモデル, 4.2.10 データベース表の同期, 2.2.1.1 sys.rqScriptCreate関数, 6.6.1 sys.rqScriptDrop関数, 6.6.1

T

表

データベースの作成, 2.2.4

データベースの削除, 2.2.4

Rでの表示, 2.2.1.4

プロキシ・オブジェクト, 2.2.1.1

サード・パーティのパッケージ, 3.3, 6.3, 6.4 transform関数

例, 3.1.6

透過層, 1.2, 1.4, 2.2 ts関数, 3.1.9

U

unique関数, 3.1.9

ore.syncに対するuse.keys引数, 2.2.2.1

V

ビュー

Rでの表示, 2.2.1.4

W

ウィンドウ関数, 3.1.9

オラクル社の法律上の注意点について

コピーライトについて

Copyright © 1994-2014, Oracle and/or its affiliates.All rights reserved.

商標と登録商標について

OracleおよびJavaはOracle Corporationおよびその関連企業の登録商標です。その他の名称は、それぞれの所有者の商標または登録商標です。

Intel、Intel Xeonは、Intel Corporationの商標または登録商標です。すべてのSPARCの商標はライセンスをもとに使用し、SPARC International, Inc.の商標または登録商標です。AMD、Opteron、AMDロゴ、AMD Opteronロゴは、Advanced Micro Devices, Inc.の商標または登録商標です。UNIXは、The Open Groupの登録商標です。

ライセンス制約の保証と結果的に生じる損害の免責

このソフトウェアおよび関連ドキュメントの使用と開示は、ライセンス契約の制約条件に従うものとし、知的財産に関する法律により保護されています。ライセンス契約で明示的に許諾されている場合もしくは法律によって認められている場合を除き、形式、手段に関係なく、いかなる部分も使用、複写、複製、翻訳、放送、修正、ライセンス供与、送信、配布、発表、実行、公開または表示することはできません。このソフトウェアのリバース・エンジニアリング、逆アセンブル、逆コンパイルは互換性のために法律によって規定されている場合を除き、禁止されています。

保証免責

ここに記載された情報は予告なしに変更される場合があります。また、誤りが無いことの保証はいたしかねます。誤りを見つけた場合は、オラクル社までご連絡ください。

制限付権利

このソフトウェアまたは関連ドキュメントを、米国政府機関もしくは米国政府機関に代わってこのソフトウェアまたは関連ドキュメントをライセンスされた者に提供する場合は、次の通知が適用されます。

U.S. GOVERNMENT END USERS: Oracle programs, including any operating system, integrated software, any programs installed on the hardware, and/or documentation, delivered to U.S. Government end users are "commercial computer software" pursuant to the applicable Federal Acquisition Regulation and agency-specific supplemental regulations.As such, use, duplication, disclosure, modification, and adaptation of the programs, including any operating system, integrated software, any programs installed on the hardware, and/or documentation, shall be subject to license terms and license restrictions applicable to the programs.No other rights are granted to the U.S. Government.

危険な用途への使用について

このソフトウェアもしくはハードウェアは様々な情報管理アプリケーションでの一般的な使用のために開発されたものです。このソフトウェアもしくはハードウェアは、危険が伴うアプリケーション（人的傷害を発生させる可能性があるアプリケーションを含む）への用途を目的として開発されていません。このソフトウェアもしくはハードウェアを危険が伴うアプリケーションで使用する際、安全に使用するために、適切な安全装置、バックアップ、冗長性（redundancy）、その他の対策を講じることは使用者の責任となります。このソフトウェアもしくはハードウェアを危険が伴うアプリケーションで使用したことに起因して損害が発生しても、オラクル社およびその関連会社は一切の責任を負いかねます。

第三者のコンテンツ、製品、サービスに対する免責事項

このソフトウェアまたはハードウェア、そしてドキュメントは、第三者のコンテンツ、製品、サービスへのアクセス、あるいはそれらに関する情報を提供することがあります。オラクル社およびその関連会社は、第三者のコンテンツ、製品、サービスに関して一切の責任を負わず、いかなる保証もいたしません。オラクル社およびその関連会社は、第三者のコンテンツ、製品、サービスへのアクセスまたは使用によって損失、費用、あるいは損害が発生しても一切の責任を負いかねます。

ドラフトのアルファ版およびベータ版ドキュメントについて

このドキュメントが試作版の場合:

このドキュメントは試作版であり、デモおよび暫定使用のみを目的としたものです。このソフトウェアを使用するハードウェアに限定するものではありません。オラクル社およびその関連会社は、このドキュメントに関して一切の責任を負わず、いかなる保証もいたしません。また、このドキュメントを使用したことによって損失、費用、あるいは損害が発生しても、一切の責任を負いかねます。