Oracle® R Enterprise

ユーザーズ・ガイド

リリース1.5

E67082-02(原本部品番号:E49688-06)

2016年8月

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

E67082-02

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

原本主著者: David McDermid

原本協力著者: Mark Hornick

原本協力者: Sherry Lamonica、Qin Wang、Lei Zhang

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

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

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

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 Corporationとの間の契約に別段の定めがある場合を除いて、Oracle Corporationおよびその関連会社は、第三者のコンテンツ、製品、サービスに関して一切の責任を負わず、いかなる保証もいたしません。適用されるお客様とOracle Corporationとの間の契約に定めがある場合を除いて、Oracle Corporationおよびその関連会社は、第三者のコンテンツ、製品、サービスへのアクセスまたは使用によって損失、費用、あるいは損害が発生しても一切の責任を負いかねます。

目次

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

はじめに

- 対象読者

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

- 関連ドキュメント

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

- 表記規則

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

- Oracle R Enterprise 1.5での変更内容

- Oracle R Enterprise 1.5での新機能

- データストアとスクリプト・リポジトリを管理するためのR

- データストアとスクリプト・リポジトリを管理するためのPL/SQLおよびデータ・ディクショナリ・ビュー

- ore.groupApply関数の変更

- ore.randomForestモデリング関数

- ore.summary関数の変更

- 統計関数メソッドの変更

- BLOBおよびCLOBデータ型のサポート

- Oracle R Enterprise 1.4.1での変更内容

- Oracle R Enterprise 1.4.1での新機能

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

- Oracle R Enterprise 1.4での変更内容

- Oracle R Enterprise 1.4での新機能

- Oracle R Enterprise 1.3での変更内容

- Oracle R Enterprise 1.3での新機能

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

- Oracle R Enterprise 1.1での変更内容

1 Oracle R Enterpriseの概要

- 1.1 Oracle R Enterpriseについて

- 1.2 Oracle R Enterpriseの利点

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

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

- 1.4.1 透過層について

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

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

- 1.4.2.2 ore.frameクラスについて

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

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

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

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

- 1.7 Oracle R Enterpriseの例

- 1.7.1 Oracle R Enterpriseの例のリスト

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

2 Oracle R Enterpriseの概要

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

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

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

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

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

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

- 2.2.1 インデータベース・データ用のRオブジェクトの作成

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

- 2.2.1.2 ore.sync関数の使用方法

- 2.2.1.3 ore.get関数の使用方法

- 2.2.1.4 ore.attach関数の使用方法

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

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

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

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

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

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

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

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

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

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

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

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

- 2.2.5.4 データストアへのアクセスの制御

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

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

- 2.2.5.7 データストアの削除

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

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

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

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

- 3.1.2 データの選択

- 3.1.2.1 列によるデータの選択

- 3.1.2.2 行によるデータの選択

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

- 3.1.3 データの索引付け

- 3.1.4 データの結合

- 3.1.5 データの集計

- 3.1.6 データの変換

- 3.1.7 データのサンプリング

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

- 3.1.9 時系列データの準備

- 3.2 データの探索

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

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

- 3.2.3 データの相互関連付け

- 3.2.4 データのクロス集計

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

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

- 3.2.7 データのランキング

- 3.2.8 データのソート

- 3.2.9 ore.summaryによるデータの集計

- 3.2.10 数値変数の分布の分析

- 3.2.11 主要コンポーネント分析

- 3.2.12 特異値分解

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

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

- 4.1 Oracle R Enterpriseモデルの構築

- 4.1.1 OREmodels関数について

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

- 4.1.3 線形回帰モデルの構築

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

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

- 4.1.6 ランダム・フォレスト・モデルの構築

- 4.2 Oracle Data Miningモデルの構築

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

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

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

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

- 4.2.3 属性評価モデルの構築

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

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

- 4.2.6 k-Meansモデルの構築

- 4.2.7 Naive Bayesモデルの構築

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

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

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

- 4.3 交差検定モデル

5 Rモデルでの予測

- 5.1 ore.predict関数について

- 5.2 ore.predict関数の使用方法

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

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

- 6.1.1 埋込みRの実行の利点

- 6.1.2 埋込みRの実行用のAPI

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

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

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

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

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

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

- 6.2.1.2 オプションの制御引数

- 6.2.1.3 戻り値の構造

- 6.2.1.4 データの入力

- 6.2.1.5 パラレル実行

- 6.2.1.6 固有の引数

- 6.2.2 Rでのスクリプトの管理

- 6.2.3 ore.doEval関数の使用方法

- 6.2.4 ore.tableApply関数の使用方法

- 6.2.5 ore.groupApply関数の使用方法

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

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

- 6.2.6 ore.rowApply関数の使用方法

- 6.2.7 ore.indexApply関数の使用方法

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

- 6.2.7.2 列並行の使用例

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

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

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

- 6.3.1.1 SQL表関数のパラメータ

- 6.3.1.2 SQL表関数の戻り値

- 6.3.1.3 埋込みRの実行でのOracle R Enterpriseへの接続

- 6.3.2 SQLでのスクリプトの管理

- 6.3.2.1 SQL APIによるスクリプトの作成

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

A Oracle R EnterpriseのSQL API

- A.1 rqDropDataStoreプロシージャ

- A.2 rqEval関数

- A.3 rqGrantプロシージャ

- A.4 rqGroupEval関数

- A.5 rqRevokeプロシージャ

- A.6 rqRowEval関数

- A.7 rqTableEval関数

- A.8 sys.rqScriptCreateプロシージャ

- A.9 sys.rqScriptDropプロシージャ

B Oracle R EnterpriseのOracle Databaseビュー

- B.1 ALL_RQ_DATASTORES

- B.2 ALL_RQ_SCRIPTS

- B.3 RQUSER_DATASTORECONTENTS

- B.4 RQUSER_DATASTORELIST

- B.5 USER_RQ_DATASTORE_PRIVS

- B.6 USER_RQ_DATASTORES

- B.7 USER_RQ_SCRIPT_PRIVS

- B.8 USER_RQ_SCRIPTS

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

索引

はじめに

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

対象読者

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

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

Oracleのアクセシビリティへの取り組みについては、Oracle Accessibility ProgramのWebサイト(http://www.oracle.com/pls/topic/lookup?ctx=acc&id=docacc)にアクセスしてください。

Oracle Supportへのアクセス

サポートをご購入の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 R Enterpriseのドキュメント・セットには、次のドキュメントが含まれています。

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

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

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

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

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

- Oracle R Enterpriseのディスカッション・フォーラム(https://community.oracle.com/community/developer/english/business_intelligence/data_warehousing/r)では、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.5での変更内容

- Oracle R Enterprise 1.4.1での変更内容

- Oracle R Enterprise 1.4での変更内容

- Oracle R Enterprise 1.3での変更内容

- Oracle R Enterprise 1.1での変更内容

Oracle R Enterprise 1.5での変更内容

Oracle R Enterprise 1.5では、Oracle R EnterpriseのデータストアとOracle Databaseのスクリプト・リポジトリ内のスクリプトを管理するための関数が導入されました。また、OREmodelパッケージの新しい関数、statsパッケージの一部の関数での新しい透過層メソッド、およびその他の機能拡張が含まれています。

Oracle R Enterprise 1.5での新機能

Oracle R Enterprise 1.5では、新しいR関数およびSQLプロシージャや新しい透過層メソッドが追加されているとともに、一部の関数の機能が拡張されています。

Oracle R Enterprise 1.5には、Oracle R EnterpriseのデータストアとOracle R EnterpriseのRスクリプト・リポジトリを管理するための新しいR関数およびSQLプロシージャが備えられています。ユーザーは、データストアおよび登録されているRスクリプトへのアクセス権を他のユーザーと共有できるようになりました。このリリースには、新しいモデリング関数ore.randomForestや、ore.frameオブジェクトを取り、パラレル処理を使用できる新しいsvdおよびprcomp統計関数メソッド、およびその他の機能拡張が含まれています。

次の各トピックでは、新しい機能について簡単に説明します。

- データストアとスクリプト・リポジトリを管理するためのR

- データストアとスクリプト・リポジトリを管理するためのPL/SQLおよびデータ・ディクショナリ・ビュー

- ore.groupApply関数の変更

- ore.randomForestモデリング関数

- ore.summary関数の変更

- 統計関数メソッドの変更

- BLOBおよびCLOBデータ型のサポート

データストアとスクリプト・リポジトリを管理するためのR

Oracle R Enterprise 1.5には、Oracle R EnterpriseのデータストアとRスクリプト・リポジトリを管理するための新しいR関数が備えられています。

データストアまたは登録されているRスクリプトの所有者は、データストアまたはスクリプトへの読取りアクセス権を他のユーザーと共有できるようになりました。また、このリリースには、データストアおよびスクリプトを作成する関数やそれらに関する情報を提供する関数の新しい引数も備えられています。このデータストアおよびスクリプト管理の機能には、RとSQLの両方のインタフェースがあります。

データストアを管理するためのR関数は次のとおりです。

- ore.delete (データストアを削除します)は変更されていません。

- ore.grantは、データストアまたはスクリプトへの読取りアクセス権を付与する新しい関数です。

- データストアからR環境にオブジェクトをロードするore.loadには、データストアの所有者を指定する新しい引数ownerがあります。

- ore.revokeは、データストアまたはスクリプトへの読取りアクセス権を取り消す新しい関数です。

- データストアを作成するore.saveには、データストアへの読取りアクセス権を付与できるかどうかを指定する新しい引数grantableがあります。

- データストアに関する情報をリストするore.datastoreには、データストアのタイプを指定する新しい引数typeがあります。typeの値は、文字列user (デフォルト)、grant、grantedおよびallです。

- データストアに関する詳細情報を提供するore.datastoreSummaryには、データストアの所有者を指定する新しい引数ownerがあります。

スクリプトを管理するためのR関数は次のとおりです。

- ore.grantは、データストアまたはスクリプトへの読取りアクセス権を付与する新しい関数です。

- ore.revokeは、データストアまたはスクリプトへの読取りアクセス権を取り消す新しい関数です。

- R関数をスクリプト・リポジトリに追加するore.scriptCreateには、globalおよびoverwriteという新しい引数があります。引数globalでは、スクリプトがグローバルであるか、プライベートであるかを指定します。グローバル・スクリプトは、すべてのユーザーが使用できるパブリック・スクリプトです。global = FALSEの場合、スクリプトへのアクセス権は、所有者が他のユーザーに付与する必要があります。引数overwriteでは、スクリプトの内容を置き換えることができるかどうかを指定します。

- スクリプトを削除するore.scriptDropには、削除するスクリプトがグローバルであるかどうかを指定するglobalと、スクリプトを削除できない場合にエラーをレポートするかどうかを指定するsilentという新しい引数があります。

- スクリプトに関する情報をリストするore.scriptListには、スクリプトのタイプを指定する新しい引数typeがあります。typeの値は、文字列user (デフォルト)、global、grant、grantedおよびallです。

- ore.scriptLoadは、スクリプトをR環境にロードする新しい関数です。

データストアとスクリプト・リポジトリを管理するためのPL/SQLおよびデータ・ディクショナリ・ビュー

Oracle R Enterprise 1.5には、Oracle R EnterpriseのデータストアとRスクリプト・リポジトリを管理するための新しいPL/SQLプロシージャが備えられています。

データストアまたは登録されているRスクリプトの所有者は、データストアまたはスクリプトへの読取りアクセス権を他のユーザーと共有できるようになりました。また、このリリースには、データストアおよびスクリプトを作成するプロシージャやそれらに関する情報を提供するプロシージャの新しい引数も備えられています。この機能には、RとSQLの両方のインタフェースがあります。Oracle Databaseのデータ・ディクショナリ・ビューは、データストアおよびスクリプトに関する情報を提供します。

Oracle R Enterpriseのデータストアおよび登録されているRスクリプトへのアクセスを制御するSQLプロシージャについては、次の各項で説明します。

- データストアを管理するためのPL/SQLプロシージャ

- スクリプトを管理するためのPL/SQLプロシージャ

- データストアのデータ・ディクショナリ・ビュー

- スクリプトのデータ・ディクショナリ・ビュー

データストアを管理するためのPL/SQLプロシージャ

データストアを管理するためのPL/SQLプロシージャは次のとおりです。

- rqDropDataStore (データストアを削除します)は変更されていません。

- rqGrantは、データストアまたはスクリプトへの読取りアクセス権を付与する新しいプロシージャです。

- rqRevokeは、データストアまたはスクリプトへの読取りアクセス権を取り消す新しいプロシージャです。

スクリプトを管理するためのPL/SQLプロシージャ

スクリプトを管理するためのPL/SQLプロシージャは次のとおりです。

- rqGrantは、データストアまたはスクリプトへの読取りアクセス権を付与する新しいプロシージャです。

- rqRevokeは、データストアまたはスクリプトへの読取りアクセス権を取り消す新しいプロシージャです。

- rqScriptCreateには、globalおよびoverwriteという新しい引数があります。引数globalでは、スクリプトがグローバルであるか、プライベートであるかを指定します。グローバル・スクリプトは、すべてのユーザーが使用できるパブリック・スクリプトです。global = FALSEの場合、スクリプトへのアクセス権は、所有者が他のユーザーに付与する必要があります。引数overwriteでは、スクリプトの内容を置き換えることができるかどうかを指定します。

- rqScriptDropには、削除するスクリプトがグローバルであるかどうかを指定するglobalと、スクリプトを削除できない場合にエラーをレポートするかどうかを指定するsilentという新しい引数があります。

データストアのデータ・ディクショナリ・ビュー

データストアに関連するOracle Databaseのディクショナリ・ビューは次のとおりです。

- ALL_RQ_DATASTORES

- RQUSER_DATASTORECONTENTS

- USER_RQ_DATASTORES

- USER_RQ_DATASTORE_PRIVS

スクリプトのデータ・ディクショナリ・ビュー

スクリプトに関連するOracle Databaseのディクショナリ・ビューは次のとおりです。

- ALL_RQ_SCRIPTS

- USER_RQ_SCRIPTS

- USER_RQ_SCRIPT_PRIVS

ore.groupApply関数の変更

関数ore.groupApplyは、複数列のパーティショニングをサポートするようになりました。

INDEX引数は、ore.factorオブジェクトか列を含むore.vectorオブジェクト、またはore.frameオブジェクトを取ることができるようになりました。それぞれの長さは引数Xと同じです。関数ore.groupApplyは、INDEXオブジェクトを使用してX内のデータをパーティショニングした後で、関数FUNに送信します。

INDEXオブジェクトを使用してデータをパーティショニングする例は、「複数列のパーティショニング」を参照してください。

ore.randomForestモデリング関数

ore.randomforest関数は、ore.frameオブジェクト内のデータに基づいてランダム・フォレスト・モデルを構築します。

これは、埋込みRの実行を使用して、データベース・サーバー上のRセッションでランダム・フォレスト・ツリーを並行して成長させます。これはore.randomforestオブジェクトを返します。Oracle R Enterprise 1.5では、関数ore.randomForestは分類をサポートしますが、回帰はサポートしません。

ore.randomforest関数は、CRAN R randomForestパッケージで採用されているものと同じアルゴリズムを使用しますが、実行時のメモリーの使用量とアンサンブル・ツリー・サイズが改善されています。

ore.randomforestモデルに対するスコアリング・メソッドpredictも並行して実行されます。使用可能なメモリーが十分ある場合は、cache.model引数をTRUEに設定することをお薦めします。そうでない場合は、メモリーの過度な使用を避けるために、cache.modelをFALSEに設定する必要があります。

ore.randomforestを使用するには、Oracle R Distribution (ORD) 3.2またはCRAN R randomForestパッケージのいずれかをインストールする必要があります。CRAN R randomForestよりもパフォーマンスおよびスケーラビリティに優れたORD 3.2の関数ore.randomforestを使用することをお薦めします。R randomForestパッケージのみをインストールしている場合、ore.randomForestは実行時に警告メッセージを発行します。CRAN R randomForestパッケージは、Oracle R Enterprise 1.5のSupporting Packagesの1つです。

グローバル・オプションore.parallelは、Oracle R Enterpriseサーバーで使用する並列度を決定します。引数groupsは、ore.randomForestモデルの粒度を制御します。

ore.randomForestの使用例は、「ランダム・フォレスト・モデルの構築」を参照してください。

ore.summary関数の変更

関数ore.summaryのパフォーマンスが向上しました。また、異なるシグネチャを持ち、一部の引数のデータ型が変更されています。

関数の構文は次のようになりました。

ore.summary(data, var, stats = c("n", "mean", "min", "max"),
class = NULL, types = NULL, ways = NULL, weight = NULL,
order = NULL, maxid = NULL, minid = NULL, mu = 0,
no.type = FALSE, no.freq = FALSE)

Oracle R Enterpriseリリース1.5と以前のリリースのore.summaryの違いは次のとおりです。

- ore.summaryのパフォーマンスが向上し、結果を返す速度が1桁以上向上しました。

- 引数var、statsおよびclassは、文字列のベクターを取るようになりました。以前は、セパレータとしてカンマを使用する連結文字列を取っていました。

- 引数typesは、class引数内の列の組合せを指定する、文字列のベクターのリストになりました。

- 引数maxidおよびminidは、文字列の名前付きベクターです。

- 引数group.byおよびno.levelは、サポートされていません。

- 以前のリリースでは、引数muはmu0という名前でした。

ore.summaryの使用例は、「ore.summaryによるデータの集計」を参照してください。

統計関数メソッドの変更

Oracle R Enterprise 1.5では、statsパッケージの関数prcompおよびsvdについて透過層メソッドが用意されています。

prcomp関数は主要コンポーネント分析を実行し、svd関数は特異値分解を実行します。これらの関数はore.frameオブジェクトを受け入れるようになり、データベースでパラレル実行を使用できるため、スケーラビリティとパフォーマンスを向上させることができます。

BLOBおよびCLOBデータ型のサポート

Oracle R Enterpriseの一部の関数では、Oracle Databaseのデータ型、BLOBおよびCLOBがサポートされるようになりました。

関数ore.pushおよびore.pullでは、データベースのデータ型、BLOBおよびCLOBがサポートされるようになりました。

埋込みRの実行のR関数では、入力オブジェクトおよび出力オブジェクトについて、データベースのデータ型、BLOBおよびCLOBがサポートされるようになりました。

BLOBおよびCLOBデータ型の使用例は、例6-11を参照してください。

Oracle R Enterprise 1.4.1での変更内容

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

- Oracle R Enterprise 1.4.1での新機能

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

Oracle R Enterprise 1.4.1での新機能

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

- ore.glm関数はモデル式のオフセット項を受け入れるようになり、この関数を使用して、一般化線形モデルの負の二項分布およびTweedie分布を適合できるようになりました。

- ore.sync関数にオプションの引数queryが追加され、データベース内にビューを作成せずに、最適化されたSQL SELECT文からore.frameオブジェクトを作成できるようになりました。この引数を使用すると、現行スキーマに対するCREATE VIEWシステム権限を持っていなくても問合せを作成できます。

関連項目:

例2-10

- シリアライズ用の新しいグローバル・オプションore.envAsEmptyenvによって、Oracle Databaseへのシリアライズ中にオブジェクト内の参照される環境を空の環境で置き換えるかどうかを指定できます。このオプションは、次の各関数で使用されます。

- ore.push: listオブジェクトの場合、オプションの引数としてenvAsEmptyenvを受け入れます。

- ore.save: 名前付き引数としてenvAsEmptyenvを取ります。

- ore.doEvalおよびその他の埋込みRの実行関数: 制御引数としてore.envAsEmptyenvを受け入れます。

前述の引数のデフォルト値は、グローバル・オプションore.envAsEmptyenvによって制御されますが、引数を使用して関数のグローバル・オプション値をオーバーライドできます。

関連項目:

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

- 「オプションの制御引数」

- ore.push関数およびore.save関数のオンライン・ヘルプ

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

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

- Comprehensive R Archive Network (CRAN)からのarulesおよびstatmodパッケージがOracle R Enterprise Supporting Packagesに追加されました。Supporting Packagesの詳細は、『Oracle R Enterpriseインストレーションおよび管理ガイド』を参照してください。

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インストレーションおよび管理ガイド』

1.1 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の利点」

1.2 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)に統合できます。

1.3 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のクラス、関数およびメソッドに関するヘルプの取得

この例では、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.frame class.
help("ore.frame")

# 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")

# 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>
# Get help on the ore.frame class.
R> help("ore.frame")       # Output not shown.

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.

# 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.4 Oracle DatabaseのデータでのRの透過的な使用について

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

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

- 透過層について

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

関連項目:

「Oracle R Enterpriseの概要」

1.4.1 透過層について

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のデータ型およびクラスの透過層サポート」を参照してください。

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

関連項目:

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

- 「Oracle R Enterpriseの概要」

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

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

aggplen = aggregate(IRIS_TABLE$Petal.Length,
by = list(species = IRIS_TABLE$Species),
FUN = mean)
aggplen
例1-2のリスト

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-3 例1-2に対応するSQL

この例では、例1-2のaggregate関数に対応する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

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

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

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

- ore.frameクラスについて

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

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

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

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

Oracle R Enterpriseは、Oracle R Enterpriseのクラスのインスタンスであるオブジェクトを作成します。Oracle R Enterpriseは、多くの標準のR関数をオーバーロードし、それらでOracle R Enterpriseのクラスおよびデータ型を使用できるようにします。R言語の構造および構文は、Oracle Databaseオブジェクトにマップされているオブジェクトでサポートされます。

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

Rデータ型

Oracle R Enterpriseデータ型

SQLデータ型

キャラクタ・モードのvector

ore.character

VARCHAR2

INTERVAL YEAR TO MONTH

整数モードの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

TIMESTAMP WITH TIME ZONE

TIMESTAMP WITH LOCAL TIME ZONE

difftime

ore.difftime

INTERVAL DAY TO SECOND

なし

未サポート

LONG

LONG RAW

RAW

ユーザー定義のデータ型

参照データ型

注意:

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

関連項目:

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

1.4.2.2 ore.frameクラスについて

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

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

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

関連項目:

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

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

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

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

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"

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

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

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

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

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

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

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-5のリスト

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

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

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

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

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

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

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

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

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

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

この図は、これらの手順および手順の一般的な繰返しを示しています。

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

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

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

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

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

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

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

- データの順序付け。

- データの中間集計。

- 時系列分析。

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

- 探索的データ分析。

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

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

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

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

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

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

グローバル

説明

ore.envAsEmptyenv

Oracle Databaseへのシリアライズ中にオブジェクト内の参照される環境を空の環境で置き換えるかどうかを指定する論理値。TRUEの場合、オブジェクト内の参照される環境は親が.GlobalEnvである空の環境で置き換えられ、参照される元の環境内のオブジェクトはシリアライズされません。これにより、シリアライズされるオブジェクトのサイズを大幅に削減できる場合があります。FALSEの場合、参照される環境内のすべてのオブジェクトがシリアライズされますが、シリアライズを解除したりメモリーにロードすることもできます。このオプションのデフォルト値はFALSEです。

このグローバル・オプションは次のOracle R Enterprise関数で使用されます。

- シリアライズされたlistオブジェクトをデータベースに保存するためのore.push

- オブジェクトをOracle R Enterpriseデータストアに保存するためのore.save

- ore.doEval、およびlistタイプのパラメータをシリアライズし、埋込みRの実行時にR関数により返されたオブジェクトをシリアライズするためのその他の埋込みR実行関数

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の使用の詳細は、「順序付けに関連するグローバル・オプション」を参照してください。

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

1.7 Oracle R Enterpriseの例

Oracle R Enterpriseには、Oracle R Enterpriseの関数の使用を示すいくつかのサンプル・スクリプトが含まれています。次の各トピックでは、サンプル・スクリプトのリストとスクリプトの実行について説明します。

- Oracle R Enterpriseの例のリスト

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

1.7.1 Oracle R Enterpriseの例のリスト

次の例に示すように、demo関数を使用してOracle R Enterpriseのサンプル・スクリプトのリストを表示できます。

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

demo(package = "ORE")

例1-6のリスト

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     Hypothesis 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_oc         Oracle Data Mining: o-cluster
odm_svm        Oracle Data Mining: support vector machines
pca            Principal Component Analysis
push_pull      RDBMS <-> R data transfer
randomForest   Random forest model
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

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

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

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

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

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

demo("basic", package = "ORE")
例1-7のリスト

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.

2 Oracle R Enterpriseの概要

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Oracle R Enterpriseの使用を開始するには、最初にore.connect関数を使用してOracle Databaseインスタンスのスキーマに接続します。Rセッション中に同時に存在できるのは、1つのOracle R Enterprise接続のみです。Rセッションがすでにデータベースに接続されている場合にore.connectを呼び出すと、アクティブな接続を終了してから新しい接続を開きます。接続を試みる前に、ore.is.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 R Enterpriseインストレーションおよび管理ガイド』を参照してください。

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

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

関連項目:

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

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

2.1.1.2 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オブジェクトの保存および管理」を参照してください。

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

この項の例では、Oracle DatabaseインスタンスへのOracle R Enterpriseの接続を指定する様々な方法を示します。各例では、ore.connect引数の値に、サンプルの値を使用しています。サンプルの値は、使用しているデータベースへの接続に適した値に置き換えてください。

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

この例では、ore.connect関数を呼び出し、user、sid、host、passwordおよびport引数を指定します。

ore.connect(user = "rquser", sid = "sales", host = "sales-server",
password = "rquserStrongPassword", port = 1521 )

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

この例では、SIDのかわりにサービス名を使用する方法を示します。さらに、ローカル・ホストへの接続も指定します。

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

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

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

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 ore.connectの使用方法および完全な接続文字列の指定

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

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 conn_string引数を使用したOracleウォレットの指定

この例では、conn_string引数を使用して、Oracleウォレットを指定します。mydb_test文字列は、Oracleデータベースの接続識別子です。Oracleウォレットには、接続を確立するために必要な情報が格納されています。Oracle R Enterprise接続のOracleウォレットを作成する方法の詳細は、『Oracle R Enterpriseインストレーションおよび管理ガイド』を参照してください。

ore.connect(conn_string = "mydb_test")

例2-6 conn_string引数の使用方法および空の接続文字列の指定

この例では、空の接続文字列を使用してローカル・ホストに接続します。

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

例2-7 プラガブル・データベースへの接続でのconn_string引数の使用方法

この例では、conn_string引数を使用してサービス名を指定して、プラガブル・データベースに接続します。

ore.connect(conn_string = "pdb1.example.com")

例2-8 プラガブル・データベースへの接続でのservice_name引数の使用方法

この例では、サービス名、ホスト名およびポート番号を使用してore.connectを呼び出し、プラガブル・データベースに接続します。

ore.connect(service_name = "pdb1.example.com", host = "mypdb", port = 1521)

例2-9 Oracle R Enterpriseセッションの切断

この例では、Oracle R EnterpriseセッションをOracleデータベースから明示的に切断します。

ore.disconnect()

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

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

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

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

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

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

2.2.1 インデータベース・データ用のRオブジェクトの作成

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

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

- ore.sync関数の使用方法

- ore.get関数の使用方法

- ore.attach関数の使用方法

2.2.1.1 データベース・オブジェクト用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オブジェクトの作成」を参照してください。

query引数を使用すると、SQL SELECT文を指定できます。これによって、データベース内にビューを作成せずに問合せ用のore.frameを作成できます。これは、現行スキーマに対してCREATE VIEWシステム権限を持っていない場合に有用です。schema引数とquery引数を同じore.sync呼出しで使用することはできません。

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

2.2.1.2 ore.sync関数の使用方法

例2-10にore.sync関数の使用を示します。この例ではまず、ore.exec関数を呼び出して、rquserのデータベース・スキーマに存在する表を表すいくつかの表を作成します。次に、ore.syncを呼び出し、スキーマの3つの表を指定します。ore.syncの呼出しによりrquserにR環境を作成し、そのスキーマ内の指定された表に対するプロキシore.frameオブジェクトを作成します。この例では、現在の環境にあるore.frameプロキシ・オブジェクトをリストします。TABLE3表はスキーマ内に存在しますが、ore.frameプロキシ・オブジェクトは含まれません(このプロキシ・オブジェクトはore.sync呼出しに含められていないため)。

次に、query引数を使用してore.syncを呼び出して、指定されたSQL問合せに対するore.frameオブジェクトを作成します。再びore.frameオブジェクトをリストします。

次にore.syncを再び呼び出し、SHスキーマにR環境を作成し、そのスキーマ内の指定された表に対するプロキシ・オブジェクトをその環境内に作成します。この例では、ore.exists関数を呼び出して、指定された表が現在の環境に存在するかどうかを確認した後に、SH環境に存在するかどうかを確認します。SH環境内のRオブジェクトをリストします。

次に、ore.frameオブジェクトのQUERY1、QUERY2およびTABLE4をrquser環境から削除します。最後に、環境内のプロキシ・オブジェクトを再びリストします。

注意:

ore.rm関数の呼出しにより、TABLE4表のプロキシであるore.frameが環境から削除されます。スキーマから表は削除されません。

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

# After connecting to a database as rquser, create some tables.
ore.exec("CREATE TABLE TABLE1 AS SELECT * FROM dual")
ore.exec("CREATE TABLE TABLE2 AS SELECT * FROM dual")
ore.exec("CREATE TABLE TABLE3 AS SELECT * FROM dual")
ore.exec("CREATE TABLE TABLE4 AS SELECT * FROM dual")
# 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()
# Create ore.frame objects for the specified queries.
ore.sync(query = c("QUERY1" = "SELECT 0 X, 1 Y FROM dual",
"QUERY2" = "SELECT 1 X, 0 Y FROM dual"))
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 objects for the specified objects.
ore.rm(c("QUERY1", "QUERY2", "TABLE4"))
# List the ore.frame proxy objects in the current environment again.
ore.ls()
例2-10のリスト

R> # After connecting to a database as rquser, create some tables.
R> ore.exec("CREATE TABLE TABLE1 AS SELECT * FROM dual")
R> ore.exec("CREATE TABLE TABLE2 AS SELECT * FROM dual")
R> ore.exec("CREATE TABLE TABLE3 AS SELECT * FROM dual")
R> ore.exec("CREATE TABLE TABLE4 AS SELECT * FROM dual")
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> # Create ore.frame objects for the specified queries.
R> ore.sync(query = c("QUERY1" = "SELECT 0 X, 1 Y FROM dual",
+                     "QUERY2" = "SELECT 1 X, 0 Y FROM dual"))
R> ore.ls()
[1] "QUERY1"     "QUERY2"     "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 objects for the specified objects.
R> ore.rm(c("QUERY1", "QUERY2", "TABLE4"))
R> # List the ore.frame proxy objects in the current environment again.
R> ore.ls()
[1] "TABLE1"     TABLE3"

2.2.1.3 ore.get関数の使用方法

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

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

この例では、ore.sync関数を呼び出して、SHスキーマのCUSTOMERS表のプロキシであるore.frameオブジェクトを作成します。次に、そのプロキシ・オブジェクトのディメンションを取得します。

ore.sync(schema = "SH", table = "CUSTOMERS", use.keys = FALSE)
dim(ore.get(name = "CUSTOMERS", schema = "SH"))
例2-11のリスト

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

2.2.1.4 ore.attach関数の使用方法

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

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

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

この例では、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-12のリスト

R> # Connected as rquser.
R> # Add the environment for the rquser schema to the R search path.
R> 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

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

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

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

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

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

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

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

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

関連項目:

「データの索引付け」

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

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

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

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.2.2.3 キーを使用した順序付け

例2-13に示すとおり、データベース表の主キーを使用してore.frameオブジェクトを順序付けできます。この例では、スパム・データセットをkernlabパッケージからロードします。2つの列をデータセットに追加します。

この例では、ore.dropを呼び出して、指定された表(存在する場合)を削除します。次に、ore.createを呼び出して、データセットから2つの表を作成します。ore.execを呼び出して、USERID列とTS列をSPAM_PK表の複合主キーにし、ore.syncを呼び出して、表をそのore.frameプロキシと同期します。

注意:

ore.exec関数は、Oracle DatabaseスキーマでSQL文を実行します。この関数は、戻り値を持たないデータベース定義言語(DDL)文を対象としています。

例2-13ではその後、各表の最初の8行を表示します。SPAM_PK表のプロキシ・オブジェクトは、順序付けられたore.frameオブジェクトです。これには、"|"文字で区切られたTS列とUSERID列の値を組み合せた行名が含まれます。SPAM_NOPK表のプロキシ・オブジェクトは順序付けられていないore.frameオブジェクトで、これには記号SPAM_NOPKが付けられます。デフォルトで、SPAM_NOPKには連番の行名が付けられます。

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

# 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-13のリスト

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.2.2.4 行名を使用した順序付け

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

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

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

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

# 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 ‘|' 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-14のリスト

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 ‘|' 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.2.2.5 順序付けられたフレームの使用方法

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

この例では、順序付けられた2つのore.frameオブジェクトと順序付けられていない2つのore.frameオブジェクトをマージした結果を示します。

# 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")
# 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-15のリスト

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> # Uing 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> # 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

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

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

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

関連項目:

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

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

- push_pull.Rのスクリプト例。

例2-16 データを移動するための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-16のリスト

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"

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

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

注意:

ore.drop関数は、データベース表およびそれに関連付けられたore.frameプロキシ・オブジェクトを削除する場合にのみ使用します。永続データベース表と関連付けられてないore.frameオブジェクトを削除する場合は、これを使用しないでください。一時データベース表のore.frameオブジェクトを削除する場合は、ore.rm関数を使用します。

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

この例では、データベース内に表を作成し、それらの一部を削除します。

# Create the AIRQUALITY table from the data.frame for the airquality data set.
ore.create(airquality, table = "AIRQUALITY")
# 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 and DF2 tables from the data.frame objects.
ore.create(df1, "DF1")
ore.create(df2, "DF2")
# Create the CARS93 table from the data.frame for the Cars93 data set.
ore.create(Cars93, table = "CARS93")
# List the Oracle R Enterprise proxy objects.
ore.ls()
# Drop the CARS93 object.
ore.drop(table = "CARS93")
# List the Oracle R Enterprise proxy objects again.
ore.ls()
例2-17のリスト

R> # Create the AIRQUALITY table from the data.frame for the airquality data set.
R> ore.create(airquality, table = "AIRQUALITY")
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")
R> ore.create(df2, "DF2")
R> # Create the CARS93 table from the data.frame for the Cars93 data set.
R> ore.create(Cars93, table = "CARS93")
R> # List the Oracle R Enterprise proxy objects.
R> ore.ls()
[1] "AIRQUALITY"  "CARS93"  "DF1"  "DF2_"
R> # Drop the CARS93 object.
R> ore.drop(table = "CARS93")
R> # List the Oracle R Enterprise proxy objects again.
R> ore.ls()
[1] "AIRQUALITY"  "DF1_"  "DF2"

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

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

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

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

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

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

- データストアへのアクセスの制御

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

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

- データストアの削除

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

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

Oracle R Enterpriseのデータストアを使用すると、Rオブジェクトをデータベースに保存できます。

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モデルを構築し、それをデータストアに保存することもできます。その後、埋込みRの実行を介してそのモデルを使用してデータベースにデータをスコアリングできます。埋込みRの実行関数でのデータストアの使用例は、例6-10を参照してください。

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

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

関数

説明

ore.datastore

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

ore.datastoreSummary

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

ore.delete

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

ore.grant

データストアへ読取りアクセス権を付与します。

ore.lazyLoad

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

ore.load

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

ore.revoke

データストアへの読取りアクセス権を取り消します。

ore.save

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

関連項目:

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

2.2.5.2 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セッションを終了すると、データベースは自動的にそのモデルを削除します。

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

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

関連項目:

- 例6-16

- 例A-6

- 例A-8

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

この例では、引数の様々な組合せを使用してデータストアを作成する方法を示します。

# 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.drop("AIRQUALITY")
ore.create(airquality, table = "AIRQUALITY")

# 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(AIRQUALITY, list = ls(), name = "ds1", description = "My private 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-18のリスト

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.drop("AIRQUALITY")
R> ore.create(airquality, table = "AIRQUALITY")
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] "AIRQUALITY"
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(AIRQUALITY, 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)

2.2.5.4 データストアへのアクセスの制御

ore.grantおよびore.revoke関数を使用すると、Oracle R Enterpriseのデータストアへのアクセス権を付与したり、取り消すことができます。

ore.grantおよびore.revoke関数では、データストアへのアクセスを制御できます。自分が所有するデータストアへの読取りアクセス権を、指定したユーザーに付与したり、アクセス権限を取り消すことができます。関数ore.save、ore.load、ore.datastoreおよびore.datastoreSummaryには、データストアのアクセス権に関連する引数があります。

注意:

ore.createを使用して永続データベース表およびそのプロキシore.frameオブジェクトを作成し、付与可能なデータストアにプロキシore.frameオブジェクトを保存した後、ore.grantを使用してデータストアへの読取りアクセス権を付与した場合、アクセス権はore.frameオブジェクトにのみ適用されます。読取りアクセス権は、永続データベース表には拡張されません。表自体への読取り権限を付与するには、適切なSQLコマンドを実行する必要があります。

例2-19 データストアへのアクセス権の付与および取消し

この例では、ローカルのRセッションからOracleデータベースにairqualityデータセットをプッシュしますが、これは、ore.frameオブジェクトAIRQUALITYとして、また、同じ名前の一時データベース表として存在します。この例では次に、AIRQUALITYオブジェクトをデータストアds3に保存し、そのデータストアへのアクセス権を他のユーザーに付与できるように指定します。type = grantableを指定して関数ore.datastoreを呼び出し、読取りアクセス権が付与されているすべてのデータストアを表示します。ds3データストアの読取り権限をSCOTTに付与します。その後、type = grantを指定してore.datastoreを呼び出し、読取りアクセス権が付与されているデータストアを表示します。SCOTTの読取り権限を取り消し、アクセス権が付与されているデータストアを再度表示します。

AIRQUALITY <- ore.push(airquality)
ore.save(AIRQUALITY, name = "ds3",
description = "My datastore 3", grantable  = TRUE)
ore.datastore(type = "grantable")
ore.datastore(type = "grant")
ore.grant("ds3", type = "datastore", user = "SCOTT")
ore.datastore(type = "grant")
ore.revoke("ds3", type = "datastore", user = "SCOTT")
ore.datastore(type = "grant")
例2-19のリスト

R> AIRQUALITY <- ore.push(airquality)
R> ore.save(AIRQUALITY, name = "ds3",
+           description = "My datastore 3", grantable  = TRUE)
R> ore.datastore(type = "grantable")
datastore.name object.count  size       creation.date    description
1            ds3            1  1451 2015-11-30 18:48:25 My datastore 3
R> ore.datastore(type = "grant")
[1] datastore.name grantee
<0 rows> (or 0-length row.names)
R> ore.grant("ds3", type = "datastore", user = "SCOTT")
R> ore.datastore(type = "grant")
datastore.name grantee
1            ds3   SCOTT
R> ore.revoke("ds3", type = "datastore", user = "SCOTT")
R> ore.datastore(type = "grant")
[1] datastore.name grantee
<0 rows> (or 0-length row.names)

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

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

ore.datastore関数を使用して、データストアに関する基本的な情報をリストできます。特定のタイプのデータストアに関する情報を取得するには、オプションの文字列引数typeを使用できます。typeの有効な値は次のとおりです。

- 現行のセッション・ユーザーが作成したデータストアをリストするuser。これはデフォルト値です。

- 現行のセッション・ユーザーが他のユーザーに読取りアクセス権を付与できないデータストアをリストするprivate。

- 現行のセッション・ユーザーが読取りアクセス権を持っているすべてのデータストアをリストするall。

- 現行のセッション・ユーザーが他のユーザーに読取り権限を付与できるデータストアをリストするgrantable。

- 現行のセッション・ユーザーが他のユーザーに読取り権限を付与したデータストアをリストするgrant。

- 他のユーザーによって現行のセッション・ユーザーに読取り権限が付与されたデータストアをリストするgranted。

タイプを指定しなかった場合、関数ore.datastoreは、データストア名、データストア内のオブジェクト数、データストアのサイズ、作成日および説明に対応する列を含むdata.frameオブジェクトを返します。行は、列datastore.nameによってアルファベット順にソートされます。タイプを指定した場合、この関数は、指定したタイプの列を含むdata.frameを返します。

名前または正規表現パターンを使用してデータストアを検索できます。

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

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

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

# The datastore objects ds1 and ds2 and objects data.frame objects df1 and df2
# were created in Example 2-18.
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-20のリスト

R> # The datastore objects ds1 and ds2 and objects data.frame objects df1 and df2
R> # were created in Example 2-18.
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 1243 2014-07-24 13:31:56 For pattern mattching
2          dfobj            2  656 2014-07-24 13:31:46            df objects
3            ds1            4 3162 2014-07-24 13:25:17          My datastore
4            ds2            2 1111 2014-07-24 13:27:26                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 1243 2014-07-24 13:31:56  For pattern mattching
2            ds1            4 3162 2014-07-24 13:25:17           My datastore
3            ds2            2 1111 2014-07-24 13:27:26                 only x

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

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

ore.datastoreSummary("ds1")
ore.datastoreSummary("ds2")
例2-21のリスト

R> ore.datastoreSummary("ds1")
object.name      class size length row.count col.count
1    AIRQUALITY  ore.frame 1077      6       153         6
2           df1 data.frame  328      2         5         2
3           df2 data.frame  328      2         5         2
4       iris_of  ore.frame 1429      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  929     20        NA        NA

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

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

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

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

この例では、ore.load関数を使用して、例2-20で作成されたデータストアからオブジェクトをリストアする方法を示します。この例は、その例と同じRセッションで実行されます。

# List the R objects.
ls()

# List the datastores.
ore.datastore()

# Delete the x and z objects.
rm(x, z)
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-22のリスト

R> # List the R objects.
R> ls()
[1] "df1"     "df2"     "iris_of" "x"       "y"       "z"
R>
R> # List the datastores.
R> ore.datastore()
datastore.name object.count size       creation.date  description
1     another_ds            3 1243 2014-07-24 13:31:56 For pattern mattching
2          dfobj            2  656 2014-07-24 13:31:46            df objects
3            ds1            4 3162 2014-07-24 13:25:17          My datastore
4            ds2            2 1111 2014-07-24 13:27:26                only x
R>
R> # Delete the x and z objects.
R> rm(x, z)
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 1243 2014-07-24 13:31:56 For pattern mattching
2          dfobj            2  656 2014-07-24 13:31:46            df objects
3            ds1            4 3162 2014-07-24 13:25:17          My datastore
4            ds2            2 1111 2014-07-24 13:27:26                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"
R> ls()
[1] "df1"     "df2"     "iris_of"

2.2.5.7 データストアの削除

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

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

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

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

# Delete the df2 object from the ds1 datastore.
ore.delete("ds1", list = "df2")
# Delete the datastore named ds1.
ore.delete("ds1")
例2-23のリスト

R> # Delete 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"

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

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

関連項目:

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

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

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

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

- データの探索

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

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

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

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

- データの選択

- データの索引付け

- データの結合

- データの集計

- データの変換

- データのサンプリング

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

- 時系列データの準備

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

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

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

- 選択

- ビニング

- サンプリング

- ソートおよび順序付け

- 集計

- 変換

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

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

3.1.2 データの選択

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

- 列によるデータの選択

- 行によるデータの選択

- 値によるデータの選択

関連項目:

- 「データの索引付け」

- sql_like.Rのスクリプト例

3.1.2.1 列によるデータの選択

例3-1では、ore.frameオブジェクトから列を選択します。まず、iris data.frameオブジェクトから、一時データベース表および対応するプロキシore.frameオブジェクトiris_ofを作成します。iris_ofの最初の3行を表示します。iris_ofから2行を選択し、それを使用してore.frameオブジェクトiris_projectedを作成します。その後、iris_projectedの最初の3行を表示します。

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

iris_of <- ore.push(iris)
head(iris_of, 3)

iris_projected = iris_of[, c("Petal.Length", "Species")]

head (iris_projected, 3)
例3-1のリスト

iris_of <- ore.push(iris)
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

R> iris_projected = iris_of[, c("Petal.Length", "Species")]

R> head (iris_projected, 3)
Petal.Length Species
1          1.4  setosa
2          1.4  setosa
3          1.3  setosa

3.1.2.2 行によるデータの選択

例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.1.2.3 値によるデータの選択

例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 値によるデータの選択

iris_of <- ore.push(iris)
# Select sepal length and species where petal length is less than 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 in which the species is setosa or versicolor.
# and the petal width is less than 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> iris_of <- ore.push(iris)
R> # Select sepal length and species where petal length is less than 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 in which the species is setosa or versicolor.
R> # and the petal width is less than 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

3.1.3 データの索引付け

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

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

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

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

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

例3-4に、文字の索引付けおよび整数の索引付けを示します。この例では、例2-13の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.1.4 データの結合

例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 local 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 local 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.1.5 データの集計

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

関連項目:

aggregate.Rのスクリプト例

例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

3.1.6 データの変換

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

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

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

関連項目:

derived.Rのスクリプト例

例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のリスト

R> # Create a function for formatting data.
R> petalCategory_fmt <- function(x) {
+    ifelse(x > 5, 'LONG',
+    ifelse(x > 2, 'MEDIUM', 'SMALL'))
+ }
R> # Create an ore.frame in database memory with the iris data set.
R> iris_of <- ore.push(iris)
R> # 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
R> # Format the data in Petal.Length column.
R> iris_of$Petal.Length <- petalCategory_fmt(iris_of$Petal.Length)
R> # 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関数の使用方法

# 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のリスト

R> # Create an ore.frame in database memory with the iris data set.
R> iris_of2 <- ore.push(iris)
R> # 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 派生列の追加

# 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)
R> # 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

3.1.7 データのサンプリング

サンプリングは統計分析の重要な機能です。通常、データのサイズを減らし、意味のある作業を実行するためにデータをサンプリングします。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オブジェクトです。

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オブジェクトを使用します。

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

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で作成しています。

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を表示します。

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つのクラスタのデータが含まれます。

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関数も使用できます。

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.1.8 データのパーティショニング

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

関連項目:

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

例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

3.1.9 時系列データの準備

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列で使用します。

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日です。

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

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

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

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

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

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

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値が含まれています。この例では、最初にMYDATA$datetime列から日付を抽出します。生成されるdateOnlyオブジェクトには、年、月および日のみを含み時間を含まないore.date値が含まれます。この例では次に、ore.datetime値を、日の名前、年の日数および年の四半期を表すore.character値およびore.integer値を持つオブジェクトに強制変換します。

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点を予測します。

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

3.2 データの探索

Oracle R Enterpriseには、探索的データ分析を実行できる関数があります。これらの関数を使用して、一般的な統計操作を実行できます。

関数およびその使用について、次の各項で説明します。

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

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

- データの相互関連付け

- データのクロス集計

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

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

- データのランキング

- データのソート

- ore.summaryによるデータの集計

- 数値変数の分布の分析

- 主要コンポーネント分析

- 特異値分解

関連項目:

「Oracle R Enterpriseでのモデルの構築」

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

探索的データ分析用の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関数プラス符号順位検定および極値からすべての統計をレポートします。

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

探索的データ分析関数の多くの例で、NARROWデータセットを使用します。NARROWは、例3-23に示すとおり、9列および1500行のore.frameです。一部の列は数値で、それ以外の列もあります。

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

この例では、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"

3.2.3 データの相互関連付け

ore.corr関数を使用して相関分析を実行できます。ore.corrを使用すると、次のことを実行できます。

- ore.frameによる数値列のピアソン、スピアマンまたはケンドール相関分析を実行します。

- 制御列を指定することによる部分相関を実行します。

- 相関の前に一部のデータを集計します。

- 結果を後処理して、Rコード・フローに統合します。
ore.corr関数の出力をRのcor関数の出力に適合させることができ、これにより、任意のR関数を使用して出力を後処理したり、出力をグラフィック関数の入力として使用できます。

この関数の引数の詳細は、help(ore.corr)を呼び出してください。

次の例にこれらの操作を示します。ほとんどの例でNARROWデータセットを使用します。詳細は、「探索的データ分析関数について」を参照してください。

例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があります。種ごとにグループ化された相関マトリクスを作成します。

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のスクリプト例

3.2.4 データのクロス集計

クロス集計は、値からなる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に示すとおり、単一列頻度表を作成することです。

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

この例では、GENDERによってグループ化されたNARROW ore.frameをフィルタします。

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 2つの列の分析

この例では、GENDERによってAGEを、CLASSによってAGEを分析します。

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の値に重み付けします。

ct <- ore.crosstab(AGE~GENDER*YRS_RESIDENCE, data=NARROW)
head(ct)
例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 クロス集計データの順序付け

クロス集計表の行の順序付けには、次に示すようないくつかの方法があります。

- 分析対象の列によるデフォルトまたはNAMEの順序付け

- 頻度カウントによるFREQの順序付け

- -NAMEまたは-FREQは、順序を逆転します

- INTERNALは、順序付けをバイパスします

この例では、頻度カウントによって順序付けした後、頻度カウントで順序を逆にします。

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$GROUP
66|F  66      F        1          1         1
70|F  70      F        1          1         1
73|M  73      M        1          1         1
74|M  74      M        1          1         1
76|F  76      F        1          1         1
77|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つ以上の列の分析

この例では、3つ以上の列の分析を示します。結果は、SQLのGROUPING SETS句の実行に似ています。

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 列の範囲の指定

この例に示すように、すべての列の名前を入力するかわりに、列の範囲を指定できます。

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)
[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 別の列の値ごとに1つのクロス集計表の作成

この例では、別の列COUNTRYの一意の値ごとに1つのクロス集計表(AGE、GENDER)を作成します。

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 2つの列の値のセットごとに1つのクロス集計表の作成

(COUNTRY、GENDER)の一意の組合せごとに1つの(AGE、EDUCATION)表を作成するこの例に示すように、クロス集計を複数の列に拡張できます。

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 階層化によるクロス集計の拡張

前の例のすべてのクロス集計表は、この例に示すように、階層化で拡張できます。

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およびビンのクロス集計を計算します。

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

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

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に従ってクロス集計を計算する必要があります。

この関数の引数の詳細は、help(ore.freq)を呼び出してください。

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

この例では、irisデータセットをデータベースにプッシュし、ore.frameオブジェクトのiris_ofを取得します。この例では、クロス集計を取得し、そこで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

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

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に、観測、適合値および予測を示します。

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は、日毎に予測値を生成するために呼び出されます。

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-39 間隔を指定した二重指数平滑法モデルの構築

この例では、TTRパッケージの株のデータを使用します。これは、日ごとの株の終値に基づいて二重指数平滑法モデルを構築します。30日間の予測株価および元の観測を図3-2に示します。

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 株価予測

3.2.7 データのランキング

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つの列のランキング

この例では、2つの列AGEおよびCLASSをランキングし、派生列としてその結果をレポートします。値は、デフォルトの順序(昇順)でランキングされます。

x <- ore.rank(data=NARROW, var='AGE=RankOfAge, CLASS=RankOfClass')

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

この例では、2つの列AGEとCLASSをランキングします。同順位がある場合、同順位のすべての値に最小値が割り当てられます。

x <- ore.rank(data=NARROW, var='AGE=RankOfAge, CLASS=RankOfClass', ties='low')

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

この例では、2つの列AGEおよびCLASSをランキングし、その結果の値をCOUNTRYに従ってランキングします。

x <- ore.rank(data=NARROW, var='AGE=RankOfAge, CLASS=RankOfClass', group.by='COUNTRY')

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

列を異なる数のパーティションにパーティショニングするには、groupsの値を変更します。たとえば、groups=4では、四分位数にパーティショニングされます。この例では、2つの列AGEおよびCLASSをランキングし、その列を十分位数(10パーティション)にパーティショニングします。

x <- ore.rank(data=NARROW, var='AGE=RankOfAge, CLASS=RankOfClass',groups=10)

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

この例では、2つの列AGEおよびCLASSをランキングし、両方の列の累積分布関数を見積もります。

x <- ore.rank(data=NARROW, var='AGE=RankOfAge, CLASS=RankOfClass',nplus1=TRUE)

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

この例では、2つの列AGEとCLASSをランキングし、2つの異なる方法でそのランクをスコアリングします。最初のコマンドは、列を百分位数(100グループ)にパーティショニングします。savageスコアリング・メソッドが指数スコアを計算し、blomスコアリングが正規スコアを計算します。

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')

3.2.8 データのソート

ore.sort関数は、by引数で指定した1つ以上の列によるデータ・フレームの柔軟なソートを可能にします。

ore.sort関数は、他のデータ事前処理関数とともに使用できます。ソートの結果を、Rの視覚化への入力に使用できます。

ore.sort関数によるソートは、Oracleデータベースで実行されます。ore.sort関数は、データベースのnls.sortオプションをサポートします。

ore.sort関数は、ore.frameを返します。

この関数の引数の詳細は、help(ore.sort)を呼び出してください。

次のほとんどの例では、NARROWデータセットを使用します。一部の例では、ONTIME_Sデータセットを使用します。

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

この例では、列AGEおよびGENDERを降順でソートします。

x <- ore.sort(data=NARROW, by='AGE,GENDER', reverse=TRUE)

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

この例では、AGEを降順で、GENDERを昇順でソートします。

x <- ore.sort(data=NARROW, by='-AGE,GENDER')

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

この例では、AGEを基準にソートし、AGEの一意の値ごとに1行を保持します。

x <- ore.sort(data=NARROW, by='AGE', unique.key=TRUE)

例3-49 重複列の削除

この例では、AGEを基準にソートし、重複する行を削除します。

x <- ore.sort(data=NARROW, by='AGE', unique.data=TRUE)

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

この例では、AGEを基準にソートし、重複する行を削除して、AGEの一意の値ごとに1行を返します。

x <- ore.sort(data=NARROW, by='AGE', unique.data=TRUE, unique.key = TRUE)

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

この例では、ソートされた出力で相対順序を維持します。

x <- ore.sort(data=NARROW, by='AGE', stable=TRUE)

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

この例では、ONTIME_Sをエアライン名を基準に降順で、出発の遅延を昇順でソートします。

sortedOnTime1 <- ore.sort(data=ONTIME_S, by='-UNIQUECARRIER,DEPDELAY')

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

この例では、ONTIME_Sをエアライン名と出発の遅延を基準にソートし、各組合せの1つを選択します(つまり、一意のキーを返します)。

sortedOnTime1 <- ore.sort(data=ONTIME_S, by='-UNIQUECARRIER,DEPDELAY',
unique.key=TRUE)

3.2.9 ore.summaryによるデータの集計

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列をロールアップ(集計)します。

ore.summary(NARROW, class = 'GENDER', var = c('AGE', 'CLASS', order = 'freq')

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

この例では、AGEの歪度を列Aとして、CLASSのスチューデントのt分布の可能性を列Bとして計算します。

ore.summary(NARROW, class = 'GENDER', var = 'AGE, CLASS', stats = 'skew(AGE) = A, probt(CLASS) = B')

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

この例では、YRS_RESIDENCEを重みとしてGENDERによって集計されたAGEの重み付けされた合計を計算します。つまりsum(var*weight)を計算します。

ore.summary(NARROW, class = 'GENDER', var = 'AGE', stats = 'sum = X', weight = 'YRS_RESIDENCE')

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

この例では、GENDERおよびMARITAL_STATUSでCLASSをグループ化します。

ore.summary(NARROW, class = c('GENDER', 'MARITAL_STATUS'), var = 'CLASS', ways = 1)

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

この例では、GENDERおよびMARITAL_STATUSによってすべての適用可能な方法でCLASSをグループ化します。

ore.summary(NARROW, class = c('GENDER', 'MARITAL_STATUS'), var = 'CLASS', ways = 'nway')

例3-59 ore.summaryを使用した列の最大値の取得

この例では、IRIS ore.frame内のSepal.Length列とSepal.Width列の最大値および対応する種をリストします。

IRIS <- ore.push(iris)
ore.summary(IRIS, c("Sepal.Length", "Sepal.Width"),
"max",
maxid=c(Sepal.Length="Species", Sepal.Width="Species"))

例3-59のリスト

R> IRIS <- ore.push(iris)
R> ore.summary(IRIS, c("Sepal.Length", "Sepal.Width"),
+                      "max",
+                      maxid=c(Sepal.Length="Species", Sepal.Width="Species"))
FREQ MAX(Sepal.Length) MAX(Sepal.Width) MAXID(Sepal.Length->Species) MAXID(Sepal.Width->Species)
1  150               7.9              4.4                    virginica                      setosa
Warning message:
ORE object has no unique key - using random order

3.2.10 数値変数の分布の分析

ore.univariate関数は、ore.frameの数値変数の分布分析を提供します。

ore.univariate関数では、次の統計が提供されています。

- summary関数によってレポートされるすべての統計

- 符号順位検定、スチューデントのt-検定

- 極値のレポート

ore.univariate関数は、すべての場合に出力としてore.frameを返します。

この関数の引数の詳細は、help(ore.univariate)を呼び出してください。

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

この例では、AGE、YRS_RESIDENCEおよびCLASSのデフォルトの単変量統計を計算します。

ore.univariate(NARROW, var="AGE,YRS_RESIDENCE,CLASS")

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

この例では、YRS_RESIDENCEの位置統計を計算します。

ore.univariate(NARROW, var="YRS_RESIDENCE", stats="location")

例3-62 完全な分位統計の計算

この例では、AGEおよびYRS_RESIDENCEの完全な分位統計を計算します。

ore.univariate(NARROW, var="AGE,YRS_RESIDENCE",stats="quantiles")

3.2.11 主要コンポーネント分析

オーバーロードされたprcompおよびprincomp関数は、主要コンポーネント分析をデータベースで並行して実行します。

prcomp関数では、変数間の共分散および相関の特異値分解が使用されます。princomp関数では、サンプル間の共分散および相関の固有分解が使用されます。

透過層メソッドore.frame-prcompおよびore.frame-princompを使用すると、ore.frameオブジェクト内のデータに対して汎用関数prcompおよびprincompを使用できます。これにより、これらの関数をデータベースでパラレル・プロセスで実行できます。

どちらの関数についても、これらのメソッドは、x引数としてore.frameを受け取る関数シグネチャおよび式を受け取るシグネチャをサポートします。ore.frameには、数値データのみが含まれている必要があります。式は、数値変数のみを参照し、レスポンス変数が含まれていないことが必要です。

関数prcompはprcompオブジェクトを返し、関数princompはprincompオブジェクトを返します。

これらの関数の引数の詳細は、help('ore.frame-prcomp')およびhelp('ore.frame-princomp')を呼び出してください。

注意:

biplot関数は、これらの透過層メソッドによって返されるオブジェクトではサポートされていません。

例3-63 prcompおよびprincomp関数の使用方法

USARRESTS <- ore.push(USArrests)

# Using prcomp

prcomp(USARRESTS)
prcomp(USARRESTS, scale. = TRUE)

# Formula interface
prcomp(~ Murder + Assault + UrbanPop, data = USARRESTS, scale. = TRUE)

# Using prcomp

princomp(USARRESTS)
princomp(USARRESTS, cor = TRUE)

# Formula interface
princomp(~ Murder + Assault + UrbanPop, data = USARRESTS, cor = TRUE)

例3-63のリスト

R> USARRESTS <- ore.push(USArrests)
R>
R> # Using prcomp
R>
R> prcomp(USARRESTS)
Standard deviations:
[1] 83.732400 14.212402  6.489426  2.482790

Rotation:
PC1         PC2         PC3         PC4
Murder   0.04170432 -0.04482166  0.07989066 -0.99492173
Assault  0.99522128 -0.05876003 -0.06756974  0.03893830
UrbanPop 0.04633575  0.97685748 -0.20054629 -0.05816914
Rape     0.07515550  0.20071807  0.97408059  0.07232502

R> prcomp(USARRESTS, scale. = TRUE)
Standard deviations:
[1] 1.5748783 0.9948694 0.5971291 0.4164494

Rotation:
PC1        PC2        PC3         PC4
Murder   0.5358995 -0.4181809  0.3412327  0.64922780
Assault  0.5831836 -0.1879856  0.2681484 -0.74340748
UrbanPop 0.2781909  0.8728062  0.3780158  0.13387773
Rape     0.5434321  0.1673186 -0.8177779  0.08902432
R>
R> # Formula interface
R> prcomp(~ Murder + Assault + UrbanPop, data = USARRESTS, scale. = TRUE)
Standard deviations:
[1] 1.3656547 0.9795415 0.4189100

Rotation:
PC1         PC2        PC3
Murder   0.6672955 -0.30345520  0.6801703
Assault  0.6970818 -0.06713997 -0.7138411
UrbanPop 0.2622854  0.95047734  0.1667309
R>
R> # Using princomp
R>
R> princomp(USARRESTS)
Call:
princomp(USARRESTS)

Standard deviations:
Comp.1    Comp.2    Comp.3    Comp.4
82.890847 14.069560  6.424204  2.457837

4  variables and  50 observations.
R> princomp(USARRESTS, cor = TRUE)
Call:
princomp(USARRESTS, cor = TRUE)

Standard deviations:
Comp.1    Comp.2    Comp.3    Comp.4
1.5748783 0.9948694 0.5971291 0.4164494

4  variables and  50 observations.
R>
R> # Formula interface
R> princomp(~ Murder + Assault + UrbanPop, data = USARRESTS, cor = TRUE)
Call:
princomp(~Murder + Assault + UrbanPop, data = USARRESTS, cor = TRUE)

Standard deviations:
Comp.1    Comp.2    Comp.3
1.3656547 0.9795415 0.4189100

3  variables and  50 observations.

3.2.12 特異値分解

オーバーロードされたsvd関数は、特異値分解をデータベースで並行して実行します。

svd関数は、ore.frameまたはore.tblmatrixオブジェクトをx引数として受け取ります。ore.frame-svdメソッドは、データベースで実行されるパラレル・プロセスにブロックSVD計算を分散します。このメソッドは、グローバル・オプションore.parallelを使用して、採用する並列度を決定します。

この関数は、引数xの特異値分解のdベクターおよびv行列成分を含むlistオブジェクトを返します。左特異ベクター行列uは返さないため、引数nuは使用されません。

この関数の引数の詳細は、help('ore.frame-svd')を呼び出してください。

例3-64 svd関数の使用方法

USARRESTS <- ore.push(USArrests)
svd(USARRESTS)

例3-64のリスト

R> USARRESTS <- ore.push(USArrests)
R> svd(USARRESTS)
$d
[1] 1419.06140  194.82585   45.66134   18.06956

$v
[,1]        [,2]        [,3]        [,4]
[1,] 0.04239181 -0.01616262  0.06588426  0.99679535
[2,] 0.94395706 -0.32068580 -0.06655170 -0.04094568
[3,] 0.30842767  0.93845891 -0.15496743  0.01234261
[4,] 0.10963744  0.12725666  0.98347101 -0.06760284

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

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セッションでロードする必要があります。

kernlabパッケージの使用例は、例2-13を参照してください。

関連項目:

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

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

- 『R Administration and Installation Guide』(http://cran.r-project.org/doc/manuals/r-release/R-admin.html)

- http://www.r-bloggers.com/installing-r-packages/

例3-65 クライアントへのサード・パーティ・パッケージのダウンロード、インストールおよびロード

この例では、CRANパッケージkernlabのダウンロード、インストールおよびロードを示します。kernlabパッケージには、カーネル・ベースの機械学習手法が含まれています。この例では、install.packages関数を呼び出してこのパッケージをダウンロードしてインストールします。次に、library関数を呼び出してパッケージをロードします。

install.packages("kernlab")
library("kernlab")
例3-65のリスト

R> install.packages("kernlab")
trying URL 'http://cran.rstudio.com/bin/windows/contrib/3.0/kernlab_0.9-19.zip'
Content type 'application/zip' length 2029405 bytes (1.9 Mb)
opened URL
downloaded 1.9 Mb

package 'kernlab' successfully unpacked and MD5 sums checked

The downloaded binary packages are in
C:\Users\rquser\AppData\Local\Temp\RtmpSKVZql\downloaded_packages
R> library("kernlab")

例3-66 kernlabパッケージ関数の使用方法

この例では、demo関数を呼び出して、kernlabパッケージ内のサンプル・プログラムを検索します。このパッケージにはサンプルが含まれていないため、この例ではksvm関数のヘルプを取得します。このヘルプからサンプル・コードを呼び出します。

demo(package = "kernlab")
help(package = "kernlab", ksvm)
data(spam)
index <- sample(1:dim(spam)[1])
spamtrain <- spam[index[1:floor(dim(spam)[1]/2)], ]
spamtest <- spam[index[((ceiling(dim(spam)[1]/2)) + 1):dim(spam)[1]], ]
filter <- ksvm(type~.,data=spamtrain,kernel="rbfdot",
+              kpar=list(sigma=0.05),C=5,cross=3)
filter
table(mailtype,spamtest[,58])
例3-66のリスト

> demo(package = "kernlab")
no demos found
> help(package = "kernlab", ksvm)    # Output not shown.
> data(spam)
> index <- sample(1:dim(spam)[1])
> spamtrain <- spam[index[1:floor(dim(spam)[1]/2)], ]
> spamtest <- spam[index[((ceiling(dim(spam)[1]/2)) + 1):dim(spam)[1]], ]
> filter <- ksvm(type~.,data=spamtrain,kernel="rbfdot",
+                kpar=list(sigma=0.05),C=5,cross=3)
> filter
Support Vector Machine object of class "ksvm"

SV type: C-svc  (classification)
parameter : cost C = 5

Gaussian Radial Basis kernel function.
Hyperparameter : sigma =  0.05

Number of Support Vectors : 970

Objective Function Value : -1058.218
Training error : 0.018261
Cross validation error : 0.08696
> mailtype <- predict(filter,spamtest[,-58])
> table(mailtype,spamtest[,58])

mailtype  nonspam spam
nonspam    1347  136
spam         45  772

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

Oracle R Enterpriseには、回帰モデル、ニューラル・ネットワーク・モデルおよびOracle Data Miningアルゴリズムに基づいたモデルを構築するための関数が用意されています。

この章では、次の項目について説明します。

- Oracle R Enterpriseモデルの構築

- Oracle Data Miningモデルの構築

- 交差検定モデル

4.1 Oracle R Enterpriseモデルの構築

Oracle R EnterpriseのパッケージOREmodelsには、ore.frameオブジェクトを使用して拡張分析データ・モデルの作成に使用できる関数(次の各項で説明します)が含まれています。

- OREmodels関数について

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

- 線形回帰モデルの構築

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

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

- ランダム・フォレスト・モデルの構築

4.1.1 OREmodels関数について

OREmodelsパッケージには、ore.frameオブジェクトを使用して拡張分析データ・モデルの構築に使用できる関数が含まれています。OREmodelsの関数を次に示します。

表4-1 OREmodelsパッケージの関数

関数

説明

ore.glm

ore.frame内のデータに対して一般化線形モデルを適合および使用します。

ore.lm

ore.frame内のデータに対して線形回帰モデルを適合します。

ore.neural

ore.frame内のデータに対してニューラル・ネットワーク・モデルを適合します。

ore.randomForest

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では多くの種類の活性化関数がサポートされているため、ユーザーは活性化関数をニューロン上で層ごとに指定できます。

- ユーザーは、0(ゼロ)を含む任意の数の非表示層からなるニューラル・ネットワーク・トポロジを指定できます。

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

ほとんどの線形回帰およびore.neuralの例では、Rによって提供されるlongleyデータセットを使用します。これはマクロ経済データセットで、共線回帰の既知の例を提供し、16年にわたり毎年観察された7つの経済変数で構成されます。

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

この例では、longleyデータセットを一時データベース表にプッシュしますが、これにはプロキシore.frameオブジェクトのlongley_ofがあり、longley_ofの最初の6行を表示します。

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

4.1.3 線形回帰モデルの構築

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 ore.lmの使用方法

この例では、longleyデータセットを一時データベース表にプッシュしますが、これにはプロキシore.frameオブジェクトのlongley_ofが含まれています。この例では、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 ore.stepwise関数の使用方法

この例では、longleyデータセットを一時データベース表にプッシュしますが、これにはプロキシore.frameオブジェクトのlongley_ofが含まれています。この例では、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.

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

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 ore.glm関数の使用方法

この例では、rpartパッケージをロードした後、プロキシore.frameオブジェクトのKYPHOSISが含まれている一時データベース表にkyphosisデータセットをプッシュします。この例では、ore.glm関数およびglm関数を使用して一般線形モデルをそれぞれ構築し、このモデルでsummary関数を呼び出します。

# 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

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

ニューラル・ネットワーク・モデルを使用すると、入力と出力との間の複雑な非リニアの関係を取得すること、つまりデータのパターンを見つけることができます。ore.neural関数は、ore.frameのデータに対して回帰用のフィードフォワードニューラル・ネットワーク・モデルを構築します。これは、ノード数を指定可能な複数の非表示層をサポートします。各層には、複数の活性化関数のいずれかを設定できます。

出力層は、単一の数値カテゴリ・ターゲットまたはバイナリのカテゴリ・ターゲットです。出力層には、任意の活性化関数を設定できます。これには、デフォルトで線形活性化関数があります。

ore.neuralの出力は、タイプore.neuralのオブジェクトになります。

ore.neural関数に対する引数の詳細は、help(ore.neural)を呼び出してください。

ore.neural関数を使用したモデル化は、センサー・データなどのノイズ・データおよび複合データに適しています。そのようなデータに発生する可能性のある問題は次のとおりです。

- ピクセル値など、(数値)予測子が多い可能性がある

- ターゲットが離散値、実数値またはそのような値のベクターである可能性がある

- トレーニング・データに(ノイズに対して堅牢な)エラーが含まれている可能性がある

- スコアリングが高速

- モデルの透過性が不要なため、モデルの解釈が困難

ニューラル・ネットワーク・モデリングの一般的な手順は次のとおりです。

1. アーキテクチャの指定

2. データの準備

3. モデルの構築

4. 停止条件(反復、許容範囲内の検証セットでのエラー)の指定

5. モデルの統計結果の表示

6. モデルの改善

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

この例では、デフォルト値(hidden sizeを1など)でニューラル・ネットワークを構築します。この例では、longleyデータセットのサブセットをデータベース・メモリーのore.frameオブジェクトに、オブジェクトtrainDataとしてプッシュします。次に、longleyの別のサブセットをオブジェクトtestDataとしてデータベースにプッシュします。この例では、trainDataを使用してニューラル・ネットワーク・モデルを構築し、testDataを使用して結果を予測します。

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 ore.neuralの使用方法および活性化の指定

この例では、irisデータセットを一時データベース表にプッシュしますが、これにはプロキシore.frameオブジェクトのIRISが含まれています。この例では、ore.neural関数を使用してニューラル・ネットワーク・モデルを構築し、層ごとに異なる活性化関数を指定します。

IRIS <- ore.push(iris)
fit <- ore.neural(Petal.Length ~ Petal.Width + Sepal.Length,
data = IRIS,
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,
+                   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

4.1.6 ランダム・フォレスト・モデルの構築

ore.randomForest関数は、ore.frameオブジェクト内のデータを分類するためのアンサンブル学習手法を提供します。

関数ore.randomForestは、データベース・サーバーで並行してツリーを成長させることにより、ランダム・フォレスト・モデルを構築します。これは、多数のディシジョン・ツリーを構築し、個々のツリーのクラスのモードであるクラスを出力します。この関数では、ディシジョン・ツリーの一般的な問題であるオーバーフィットが回避されます。

Leo BreimanとAdele Cutlerによって開発されたランダム・フォレスト・アルゴリズムでは、バギングの概念と変数のランダムな選択を組み合せることにより、分散が制御されたディシジョン・ツリーの集合が生成されます。ランダム・フォレスト・アルゴリズムは高い精度を備えていますが、大規模なデータセットについては、パフォーマンスとスケーラビリティが問題になることがあります。

関数ore.randomForestは、モデルの構築およびスコアリングのために並行して実行されます。パラレル実行は、Oracle R Distribution (ORD)のrandomForestパッケージを使用している場合にも、オープン・ソースのrandomForestパッケージ4.6-10を使用している場合にも、発生することがあります。ore.randomForestおよびORDを使用すると、オープン・ソースのパッケージとともにore.randomForestを使用するよりも、必要なメモリーが少なくなる可能性があります。オープン・ソースのrandomForestパッケージを使用すると、Oracle R Enterpriseでは警告が発行されます。

関数ore.randomForestは、グローバル・オプションore.parallelを使用して、採用する並列度を決定します。この関数は、ore.randomForestオブジェクトを返します。

ore.randomForestオブジェクトに対するスコアリング・メソッドpredictの呼出しも、データベース・サーバーで並行して実行されます。cache.model引数では、予測中にランダム・フォレスト・モデル全体をメモリーにキャッシュするかどうかを指定します。使用可能なメモリーが十分ある場合は、パフォーマンスを向上させるために、cache.modelのデフォルト値であるTRUEを使用してください。

grabTreeメソッドは、指定されたツリーに関する情報を格納するore.frameオブジェクトを返します。ore.frameの各行は、ツリーの1つのノードを表します。

注意:

関数ore.randomForestは、並行して実行されている各埋込みRセッションのトレーニング・データのコピーをロードします。大規模なデータセットの場合、これは、使用可能なメモリーの量を超えることがあります。パラレル・プロセスの数および使用可能なメモリーの量を適宜調整することをお薦めします。グローバル・オプションore.parallelで、パラレル・プロセスの数を指定します。埋込みRの実行プロセスで使用されるメモリーの量を制御する方法の詳細は、『Oracle R Enterpriseインストレーションおよび管理ガイド』を参照してください。

例4-7 ore.randomForestの使用方法

# Using the iris dataset
IRIS <- ore.push(iris)
mod <- ore.randomForest(Species~., IRIS)
tree10 <- grabTree(mod, k = 10, labelVar = TRUE)
ans <- predict(mod, IRIS, type="all", supplemental.cols="Species")
table(ans$Species, ans$prediction)

# Using the infert dataset
INFERT <- ore.push(infert)
formula <- case ~ age + parity + education + spontaneous + induced

rfMod <- ore.randomForest(formula, INFERT, ntree=1000, nodesize = 2)
tree <- grabTree(rfMod, k = 500)

rfPred <- predict(rfMod, INFERT, supplemental.cols = "case")

confusion.matrix <- with(rfPred, table(case, prediction))

confusion.matrix

例4-7のリスト

R> # Using the iris dataset
R> IRIS <- ore.push(iris)
R> mod <- ore.randomForest(Species~., IRIS)
R> tree10 <- grabTree(mod, k = 10, labelVar = TRUE)
R> ans <- predict(mod, IRIS, type="all", supplemental.cols="Species")
R> table(ans$Species, ans$prediction)

setosa versicolor virginica
setosa         50          0         0
versicolor      0         50         0
virginica       0          0        50

# Using the infert dataset
R> INFERT <- ore.push(infert)
R> formula <- case ~ age + parity + education + spontaneous + induced
R>
R> rfMod <- ore.randomForest(formula, INFERT, ntree=1000, nodesize = 2)
R> tree <- grabTree(rfMod, k = 500)
R>
R> rfPred <- predict(rfMod, INFERT, supplemental.cols = "case")
R>
R> confusion.matrix <- with(rfPred, table(case, prediction))

R> confusion.matrix
prediction
case   0   1
0 154  11
1  27  56

4.2 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概要』

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

Oracle Data Miningでは、表、ビュー、スター・スキーマ、トランザクション・データおよび非構造化データのマイニングが可能です。OREdm関数は、対応する予測分析関数およびデータ・マイニング関数に、一般的なRの使用法に適合した引数を使用するRインタフェースを提供します。

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

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

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

4.2.1.1 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

サポート・ベクター・マシン

分類および回帰

4.2.1.2 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オブジェクトの存在から切り離して使用できます。

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

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-8 ore.odmAssocRules関数の使用方法

この例では、トランザクション・データセットに基づいて相関モデルを構築します。パッケージarulesおよびarulesVizは、生成されるルールおよびアイテムセットをクライアントのRセッションのメモリーにプルして表示するために必要です。このルールのグラフを図4-1に示します。

# 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-8のリスト

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 相関ルールの視覚的デモンストレーション

4.2.3 属性評価モデルの構築

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-9 ore.odmAI関数の使用方法

この例では、data.frameのirisをore.frameのiris_ofとしてデータベースにプッシュします。この例では次に、属性評価モデルを構築します。

iris_of <- ore.push(iris)
ore.odmAI(Species ~ ., iris_of)
例4-9のリスト

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

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

ore.odmDT関数は、Oracle Data Miningディシジョン・ツリー・アルゴリズムを使用しますが、これは条件付確率を基にしています。ディシジョン・ツリーはルールを生成します。ルールは、ユーザーが容易に理解でき、レコード・セットを識別するためにデータベース内で使用できる条件文です。

ディシジョン・ツリー・モデルは分類モデルです。

ディシジョン・ツリーは、一連の質問を問うことによってターゲット値を予測します。各段階で問われる質問はそれぞれ、直前の質問に対する回答によって決まります。最終的に特定のターゲット値を一意に識別できるような質問を重ねていきます。図形的には、このプロセスがツリー構造を形成します。

ディシジョン・ツリー・アルゴリズムは、トレーニング・プロセスにおいて、ケース(レコード)のセットを2つの子ノードに分割する最も効率的な方法を繰り返し見つける必要があります。ore.odmDT関数では、この分岐の計算用に2つの同種メトリック(giniおよびentropy)を使用できます。デフォルトのメトリックはジニです。

ore.odmDT関数の引数の詳細は、help(ore.odmDT)を呼び出してください。

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

この例では、入力ore.frameを作成し、モデルを構築して、予測を行い、混同マトリクスを生成します。

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-10のリスト

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

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

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-11 線形回帰モデルの構築

この例では、longleyデータセットを使用して線形回帰モデルを構築します。

longley_of <- ore.push(longley)
longfit1 <- ore.odmGLM(Employed ~ ., data = longley_of)
summary(longfit1)
例4-11のリスト

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-12 ore.odmGLMモデルの係数に対するリッジ推定の使用方法

この例では、例4-11のlongley_ofのore.frameを使用します。例4-12では、ore.odmGLM関数を呼び出し、係数のリッジ推定を使用して指定します。

longfit2 <- ore.odmGLM(Employed ~ ., data = longley_of, ridge = TRUE,
ridge.vif = TRUE)
summary(longfit2)
例4-12のリスト

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-13 ロジスティック回帰GLMの構築

この例では、ロジスティック回帰(分類)モデルを構築します。ここでは、infertデータセットを使用します。この例では、ore.odmGLM関数を呼び出し、logisticをtype引数(二項分布GLMを構築します)として指定します。

infert_of <- ore.push(infert)
infit1 <- ore.odmGLM(case ~ age+parity+education+spontaneous+induced,
data = infert_of, type = "logistic")
infit1
例4-13のリスト

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-14 ロジスティック回帰GLMの構築での参照値の指定

この例では、ロジスティック回帰(分類)モデルを構築し、参照値を指定します。この例では、例4-13のinfert_ofのore.frameを使用します。

infit2 <- ore.odmGLM(case ~ age+parity+education+spontaneous+induced,
data = infert_of, type = "logistic", reference = 1)
infit2
例4-14のリスト

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

4.2.6 k-Meansモデルの構築

ore.odmKM関数は、Oracle Data Miningのk-Means (KM)アルゴリズムを使用しますが、これは、指定した数のクラスタにデータを分割する、距離ベースのクラスタリング・アルゴリズムです。このアルゴリズムには、次の機能があります。

- 複数の距離関数(ユークリッド、コサインおよび高速コサインの各距離関数)。デフォルトはユークリッドです。

- クラスタごとに、アルゴリズムによって、重心、各属性のヒストグラム、およびクラスタに割り当てられるデータの大部分を囲むハイパーボックスを記述するルールが戻されます。重心は、カテゴリ属性については最頻値を、数値属性については平均および分散をレポートします。

ore.odmKM関数の引数の詳細は、help(ore.odmKM)を呼び出してください。

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

この例では、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関数で表示されるグラフを示します。

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)
# 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-15のリスト

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)
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> 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-15のhistogram関数の呼出しで表示されるグラフを示します。

図4-2 km.mod1モデルのクラスタ・ヒストグラム

図4-3に、例4-15のpoints関数の呼出しで表示されるグラフを示します。

図4-3 km.mod1モデルのpoints関数の結果

4.2.7 Naive Bayesモデルの構築

ore.odmNB関数は、Oracle Data MiningのNaive Bayesモデルを構築します。Naive Bayesアルゴリズムは条件付き確率に基づいています。Naive Bayesは履歴データを検索し、属性値の頻度と属性値の組合せの頻度を観測することによってターゲット値の条件付き確率を計算します。

Naive Bayesでは、各予測子は他の予測子とは条件的に独立していると想定されます。(Bayesの定理では、予測子が独立している必要があります。)

ore.odmNB関数の引数の詳細は、help(ore.odmNB)を呼び出してください。

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

この例では、入力ore.frameを作成し、Naive Bayesモデルを構築して、予測を行い、混同マトリクスを生成します。

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-10のリスト

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

4.2.8 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-17 ore.odmNMF関数の使用方法

この例では、トレーニング・データセットに基づいてNMFモデルを作成し、テスト・データセットに基づいてスコアリングします。

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-17のリスト

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

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

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アルゴリズムでは、モデルを構築する際に、必ずしもすべての入力データを使用するわけではありません。データはバッチで読み込みます(デフォルトのバッチ・サイズは50,000)。統計テストに基づいて、まだ見つかっていないクラスタが存在すると考えられる場合にのみ、別のバッチを読み込みます。

- O-Clusterは、すべてのデータを読み込むことなくモデルの作成を停止する場合があるので、データをランダム化しておくことをお薦めします。

- 2項属性は、質的属性として宣言する必要があります。O-Clusterは、質的データを数値にマップします。

- ビンの必要数の概算が自動化されたOracle Data Miningの等幅ビニング変換を使用することを強くお薦めします。

- 外れ値が存在すると、クラスタリング・アルゴリズムに大きな影響を与える可能性があります。ビニングまたは正規化を行う前に、クリッピング変換を実行してください。等幅ビニングで外れ値が存在すると、O-Clusterでクラスタを検出できなくなる場合があります。その結果、母集団全体が1つのクラスタ内に含まれているように見えます。

formula引数の仕様には~ termsがあり、ここでtermsはモデルに含まれる列名です。複数のterms項目は列名の間に+を使用することで指定されます。~ .は、dataのすべての列をモデル構築に使用する場合に使用します。列を除外するには、除外する各列名の前に-を使用します。

ore.odmOC関数の引数の詳細は、help(ore.odmOC)を呼び出してください。

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

この例では、統合データセットに基づいてOCモデルを作成します。図4-4に、生成されるクラスタのヒストグラムを示します。

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-18のリスト

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関数の出力

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

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-19 ore.odmSVM関数の使用方法および混同マトリクスの生成

この例では、SVM分類の使用方法を示します。この例では、Rのmtcarsデータセットからデータベースにmtcarsを作成し、分類モデルを構築し、予測を行い、最終的に、混同マトリクスを生成します。

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-19のリスト

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-20 ore.odmSVM関数の使用方法および回帰モデルの構築

この例では、SVM回帰を示します。この例では、データ・フレームを作成し、それを表にプッシュしてから、回帰モデルを構築します(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-20のリスト

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

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

この例では、SVN異常検出を示します。ここでは、分類の例で作成されたmtcars_ofを使用し、異常検出モデルを構築します。

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-21のリスト

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

4.3 交差検定モデル

予測モデルは通常、特定のデータに基づいて構築され、別に保存されているデータや未知データに基づいて検証されます。交差検定とはモデル改善手法の1つであり、使用可能なデータから繰り返しサンプリングを行って複数のモデルを構築およびテストすることにより、1回の学習/試験実験に伴う制約を回避します。その目的は、モデルが新しいデータに対して適切に一般化されるかを見極め、過剰適合の発生や、誤解を招きやすい既知データ特徴から誤った結論が導き出されるのを回避することにあります。

ore.CVユーティリティのR関数は、Oracle R Enterpriseを使用して回帰モデルと分類モデルの交差検定を実行します。関数ore.CVは、Oracle R Technologiesの次のブログ投稿からダウンロードできます。

https://blogs.oracle.com/R/entry/model_cross_validation_with_ore

関数ore.CVは、アルゴリズムおよびケースの選択セットに対して、Oracle R Enterpriseの回帰関数および分類関数によりインデータベース・データを使用して生成されたモデルに対する交差検定を実行します。

ore.CV関数は、次のOracle R Enterprise関数により生成されたモデルに使用できます。

- ore.lm

- ore.stepwise

- ore.glm

- ore.neural

- ore.odmDT

- ore.odmGLM

- ore.odmNB

- ore.odmSVM

また、ore.CVを使用すると、Oracle R Enterprise埋込みRの実行によってR回帰関数で生成されたモデルを交差検定することもできます。これらのR関数は次のとおりです。

- lm

- glm

- svm

ore.CVの使用方法の詳細と使用例、および関数自体をダウンロードする方法は、次のブログ投稿を参照してください。

https://blogs.oracle.com/R/entry/model_cross_validation_with_ore

5 Rモデルでの予測

この章では、Oracle R Enterprise関数ore.predictについて説明し、その使用例をいくつか示します。この章の内容は次のとおりです。

- ore.predict関数について

- ore.predict関数の使用方法

5.1 ore.predict関数について

予測モデルにより過去の動作に基づいて将来の動作を予測できます。モデルを構築した後に、そのモデルを使用して新しいデータのスコアリング、すなわち予測を行います。

Rにより様々なモデルを構築できます。Rモデルを使用して新しい結果を予測するためにデータのスコアリングをするときは、スコアリングするデータはR data.frameにある必要があります。ore.predict関数を使用すると、Rモデルを使用してore.frameオブジェクトにあるデータベース常駐データをスコアリングできます。

ore.predict関数は、Oracle DatabaseでスコアリングするためにRベースのモデルを操作可能にする最短の方法を提供します。この関数には、PMMLまたは他のプラグインに対する依存性がありません。

ore.predict関数を使用してデータベースのデータをスコアリングすると、次のようなメリットがあります。

- Rで生成されたモデルを使用してインデータベース・データをスコアリングできます。
スコアリングするデータは、ore.frameオブジェクト内にあります。

- 計算エンジンとしてのOracle Databaseを最大限に活用できます。
データベースにより、業務用で高性能のスケーラブルなスコアリング・エンジンが提供されます。

- アプリケーション・ワークフローを簡略化できます。
モデルからSQLのスコアリングまで1つの手順で移動できます。

ore.predict関数は汎用関数です。次のように使用します。

ore.predict(object, newdata, ...)

object引数の値は、表5-1にリストされているモデル・オブジェクトのいずれかです。newdata引数の値は、スコアリングするデータが含まれているore.frameオブジェクトです。ore.predict関数には、固有のRモデル・クラスで使用するためのメソッドがあります。...引数は、各種のメソッドで受け入れられる様々な追加の引数を表します。

関数ore.predictには、表5-1にリストされているモデル・オブジェクトをサポートするメソッドがあります。

表5-1 ore.predict関数でサポートされているモデル

モデルのクラス

モデルの説明

glm

一般化線形モデル

kmeans

k-Meansクラスタリング・モデル

lm

線形回帰モデル

matrix

hclust階層クラスタリング・モデル内で使用するための1000行以下のmatrix

multinom

多項対数線形モデル

nnet

ニューラル・ネットワーク・モデル

ore.model

OREModelsパッケージからのOracle R Enterpriseモデル

prcomp

マトリクス上の主要コンポーネント分析

princomp

数値マトリクス上の主要コンポーネント分析

rpart

再帰分割および回帰ツリー・モデル

ore.predictメソッドの関数シグネチャについては、help("ore.predict-kmeans")のように、次のものに対してhelp関数を呼び出してください。

- ore.predict-glm

- ore.predict-kmeans

- ore.predict-lm

- ore.predict-matrix

- ore.predict-multinom

- ore.predict-nnet

- ore.predict-ore.model

- ore.predict-prcomp

- ore.predict-princomp

- ore.predict-rpart

5.2 ore.predict関数の使用方法

次の例では、ore.predict関数の使用方法を示します。

- 例5-1

- 例5-2

- 例5-3

例5-1 線形回帰モデルでのore.predict関数の使用方法

この例では、iris data.frameでlm関数を使用して、線形回帰モデルirisModelを構築します。データセットを一時表IRISおよび対応するore.frameプロキシIRISとしてデータベースにプッシュします。このモデルでore.predictを呼び出してモデルをスコアリングし、予測をIRIS ore.frameオブジェクトと結合します。最後に、結果のオブジェクトの最初の6行を表示します。

IRISModel <- lm(Sepal.Length ~ ., data = iris)
IRIS <- ore.push(iris)
IRIS_pred <- ore.predict(IRISModel, IRIS, se.fit = TRUE,
interval = "prediction")
IRIS <- cbind(IRIS, IRIS_pred)
head(IRIS)
例5-1のリスト

R> IRISModel <- lm(Sepal.Length ~ ., data = iris)
R> IRIS <- ore.push(iris)
R> IRIS_pred <- ore.predict(IRISModel, IRIS, se.fit = TRUE,
+                              interval = "prediction")
R> IRIS <- cbind(IRIS, IRIS_pred)
R> head(IRIS)
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)
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 一般化線形回帰モデルでのore.predict関数の使用方法

この例では、infertデータセットを使用して一般化線形モデルを構築した後、そのモデルで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

例5-3 ore.modelモデルでのore.predict関数の使用方法

この例では、irisデータセットを一時表IRISおよび対応するore.frameプロキシIRISとしてデータベースにプッシュします。ore.lm関数を使用して線形回帰モデルIRISModel2を構築します。モデルをスコアリングし、列がIRISに追加します。

IRIS <- ore.push(iris)
IRISModel2 <- ore.lm(Sepal.Length ~ ., data = IRIS)
IRIS$PRED <- ore.predict(IRISModel2, IRIS)
head(IRIS, 3)
例5-3のリスト

R> IRIS <- ore.push(iris)
R> IRISModel2 <- ore.lm(Sepal.Length ~ ., data = IRIS)
R> IRIS$PRED <- ore.predict(IRISModel, IRIS)
R> head(IRIS, 3)
Sepal.Length Sepal.Width Petal.Length Petal.Width Species     PRED
1          5.1         3.5          1.4         0.2  setosa 5.004788
2          4.9         3.0          1.4         0.2  setosa 4.756844
3          4.7         3.2          1.3         0.2  setosa 4.773097

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

Oracle R Enterpriseの埋込みRの実行では、Oracle Databaseサーバーで稼働するRセッションでRスクリプトを起動できます。この章では、埋込みRの実行について、次の各項で説明します。

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

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

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

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

Oracle R Enterpriseの埋込みRの実行では、RスクリプトをOracle R EnterpriseのRスクリプト・リポジトリに格納し、そのようなスクリプトを起動できます。スクリプトを起動すると、そのスクリプトは、データベース・サーバーで稼働しデータベースにより動的に起動されて管理される1つ以上のRエンジンで実行されます。Oracle R Enterpriseでは、埋込みRの実行用にRインタフェースとSQLインタフェースの両方が提供されています。同じRスクリプトから、構造化データ、RオブジェクトおよびイメージのXML表現、さらにはデータベース表のBLOB列を介してPNGイメージを取得できます。

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

- 埋込みRの実行の利点

- 埋込みRの実行用のAPI

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

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

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

6.1.1 埋込みRの実行の利点

埋込みRの実行には次の利点があります。

- Oracle DatabaseサーバーからローカルのRセッションへデータを移動する必要がありません。
セキュリティを向上するでなく、Oracle Databaseと内部Rエンジン間のデータベース・データの転送は、別個のクライアントRエンジンよりはるかに高速です。

- データベース・サーバーを使用して、サーバーで稼働するRエンジンでRスクリプトの実行を開始、管理および制御します。

- Rエンジンの実行に、データベース・サーバー・マシンのメモリーおよび処理能力を活用することで、より優れたスケーラビリティおよびパフォーマンスを提供します。

- Hadoopのマップ/リデュース・ジョブの特殊なケースに対応したユーザー定義のR関数をデータ・パラレルおよびタスク・パラレルに実行できます。

- パラレル・シミュレーション機能が装備されています。

- データベース・サーバーで稼働するRスクリプトで、オープン・ソースのCRANパッケージを使用できます。

- R環境を終了することなく、分析アプリケーション用の包括的なスクリプトを1つの手順で開発および操作できるようにする機能が装備されています。
探索的分析で使用されるRスクリプトをアプリケーション・タスクに直接統合できます。また、移植を排除し、アプリケーション・コードに対する変更の即時更新を可能にすることによって、本番でRスクリプトをすばやく起動して、開発期間を大幅に減少できます。

- SQLからRスクリプトを実行することで、Rスクリプトの結果をOracle Business Intelligence Enterprise Edition (OBIEE)、Oracle BI Publisherおよび構造化データ、Rオブジェクトおよびイメージ用のその他のSQL対応のツールと統合できます。

6.1.2 埋込みRの実行用のAPI

Oracle R Enterpriseには、埋込みRの実行用のRおよびSQLのアプリケーション・プログラミング・インタフェースがあります。次の表は、埋込みRの実行およびRスクリプト・リポジトリの管理用のR関数とそれに対応するSQL関数およびプロシージャのリストです。関数fは、Oracle R Enterpriseの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.grant

rqGrant

データストアまたはスクリプトへの読取りアクセス権を付与します。

ore.revoke

rqRevoke

データストアまたはスクリプトへの読取りアクセス権を取り消します。

ore.scriptCreate

sys.rqScriptCreate

指定されたR関数を、指定された名前でOracle R EnterpriseのRスクリプト・リポジトリに追加します。

ore.scriptDrop

sys.rqScriptDrop

指定されたR関数をOracle R EnterpriseのRスクリプト・リポジトリから削除します。

ore.scriptList

ALL_RQ_SCRIPTS
USER_RQ_SCRIPTS

スクリプトに関する情報をリストします。

ore.scriptLoad

該当なし

スクリプトのR関数をR環境にロードします。

関連項目:

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

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

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

Rスクリプトではデータベース・サーバーへのアクセスが許可されるため、スクリプトの作成を制御する必要があります。RQADMINロールは、ユーザーがスクリプトを作成してOracle R EnterpriseのRスクリプト・リポジトリに格納したり、スクリプトをリポジトリから削除するために必要なOracle Database権限の集合です。

Oracle R Enterpriseをデータベース・サーバーにインストールすると、RQADMINロールが作成されます。このロールは、明示的にユーザーに付与する必要があります。RQADMINをユーザーに付与するには、SQL*Plusをsysdbaで起動し、次のようなGRANT文(ロールをユーザーRQUSERに付与します)を入力します。

GRANT RQADMIN to RQUSER

注意:

RQADMINは、必要とするユーザーにのみ付与してください。

スクリプトを作成するとき、所有者は、global引数を使用して、スクリプトがパブリックであるか、プライベートであるかを指定できます。global = TRUEの場合、すべてのユーザーにスクリプトへの読取りアクセス権があります。global = FALSEの場合(デフォルト)、所有者は、他のユーザーにアクセス権を付与することにより、スクリプトを共有できます。所有者は、アクセス権をいつでも取り消すことができます。

関連項目:

- 「Rでのスクリプトの管理」

- 「SQLでのスクリプトの管理」

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

Oracle R Enterpriseの埋込みRの実行関数の一部では、データベースでのパラレル実行の使用がサポートされています。関数ore.groupApply、ore.rowApply、rq.groupEvalおよびrq.rowEvalはデータ・パラレル実行をサポートし、ore.indexApplyはタスク・パラレル実行をサポートします。このパラレル実行機能によって、Oracle Exadataデータベース・マシンなどの高パフォーマンスのコンピューティング・ハードウェアをスクリプトで利用できます。

関数ore.groupApply、ore.rowApplyおよびore.indexApplyのparallel引数には、埋込みRの実行で使用する並列度を指定します。引数の値には、次のいずれかを指定できます。

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

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

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

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

この引数のデフォルト値は、グローバル・オプションore.parallelの値、またはore.parallelが設定されていない場合はFALSEです。

ore.doEvalまたはore.tableApplyを使用して呼び出したユーザー定義のR関数は、並行して実行されません。このような関数は1つのRエンジンで実行されます。

rq.groupEval関数およびrq.rowEval関数の場合、並列度は入力カーソル引数のPARALLELヒントによって指定します。

ore.groupApply関数およびrq.groupEval関数のデータ・パラレル実行では、1つ以上のRエンジンが同じR関数(タスク)を別のデータ・パーティションで実行します。この機能によって、たとえば何万または何十万もの予測モデルを顧客に1モデルずつ構築するなどの、多数のモデルの構築が可能です。

ore.rowApply関数およびrq.rowEval関数のデータ・パラレル実行では、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のグローバル・オプション」

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

埋込みRの実行では、Oracle Databaseサーバーで実行されるユーザー定義のR関数で、CRANまたは他のサード・パーティのパッケージを使用できます。埋込みRの実行でサード・パーティのパッケージを使用するには、そのパッケージをデータベース・サーバーにインストールする必要があります。埋込みRの実行用のRインタフェースでこのパッケージを使用する場合は、パッケージをクライアントにもインストールする必要があります。非互換性を回避するために、クライアント・マシンとサーバー・マシンの両方に同じバージョンのパッケージをインストールする必要があります。

Oracle Database管理者(DBA)は、埋込みR関数またはすべてのRユーザーが使用できるようにパッケージをデータベース・サーバーにインストールできます。DBAは、パッケージを1つまたは複数のデータベース・サーバーにインストールできます。

通常、DBAは次の手順を実行します。

1. CRANからパッケージをダウンロードしてインストールします。CRANからパッケージをダウンロードするには、インターネット接続が必要です。

2. サーバーで稼働するOracle R Enterpriseセッションで、パッケージをロードします。パッケージ内の関数を使用して、パッケージが正しくインストールされていることを確認します。

1つのデータベース・サーバーにパッケージをインストールするには、次のいずれかを実行します。

- サーバーで稼働するOracle R Enterpriseセッションで、例6-1に示すようなinstall.packages関数を呼び出します。この関数によって自動的にパッケージがダウンロードされ、依存性がインストールされます。

- wgetを使用してCRANからパッケージ・ソースをダウンロードします。このパッケージが、使用されているR Distribution内にないパッケージのいずれかに依存している場合は、それらのパッケージもダウンロードします。
オペレーティング・システムのコマンドラインからORE CMD INSTALLコマンドを使用して、このパッケージをOracle R Enterpriseパッケージと同じ場所($ORACLE_HOME/R/library)にインストールします。例6-2を参照してください。

パッケージおよび依存パッケージをOracle Real Application Clusters (Oracle RAC)や複数ノードのOracle Exadataデータベース・マシン環境などの複数のデータベース・サーバーにインストールする場合は、例6-3に示すように、Exadata Distributed Command Line Interface (DCLI)ユーティリティを使用します。DCLIを使用してパッケージをインストールする手順の詳細は、『Oracle R Enterpriseインストレーションおよび管理ガイド』を参照してください。

パッケージが正しくインストールされたことを確認するには、例6-4に示すように、パッケージをロードしてパッケージ内の関数を使用します。

例6-1 Oracle R Enterpriseセッションでの単一データベースへのパッケージのインストール

この例では、install.packages関数を呼び出して、CRANからC50パッケージをダウンロードし、インストールします。C50パッケージには、C5.0ディシジョン・ツリーおよびパターン認識用のルールベース・モデルを作成するための関数が含まれています。

この例の出力は示されていませんが、例6-2のORE CMD INSTALLコマンドの出力とほとんど同じです。

install.packages("c50")

例6-2 コマンドラインからの単一データベースへのパッケージのインストール

この例では、LinuxコマンドラインからORE CMD INSTALLを使用して、CRANからC50パッケージをダウンロードし、インストールする方法を示します。

wget http://cran.r-project.org/src/contrib/C50_0.1.0-19.tar.gz
ORE CMD INSTALL C50_0.1.0-19.tar.gz
例6-2のリスト

$ wget http://cran.r-project.org/src/contrib/C50_0.1.0-19.tar.gz
# The output of wget is not shown.
$ ORE CMD INSTALL C50_0.1.0-19.tar.gz
* installing to library '/example/dbhome_1/R/library'
* installing *source* package 'C50' ...
** package 'C50' successfully unpacked and MD5 sums checked
checking for gcc... gcc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables...
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
configure: creating ./config.status
config.status: creating src/Makevars
** libs
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c attwinnow.c -o attwinnow.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c classify.c -o classify.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c confmat.c -o confmat.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c construct.c -o construct.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c contin.c -o contin.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c discr.c -o discr.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c formrules.c -o formrules.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c formtree.c -o formtree.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c getdata.c -o getdata.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c getnames.c -o getnames.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c global.c -o global.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c hash.c -o hash.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c hooks.c -o hooks.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c implicitatt.c -o implicitatt.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c info.c -o info.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c mcost.c -o mcost.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c modelfiles.c -o modelfiles.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c p-thresh.c -o p-thresh.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c prune.c -o prune.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c rc50.c -o rc50.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c redefine.c -o redefine.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c rsample.c -o rsample.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c rulebasedmodels.c -o rulebasedmodels.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c rules.c -o rules.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c ruletree.c -o ruletree.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c siftrules.c -o siftrules.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c sort.c -o sort.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c strbuf.c -o strbuf.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c subset.c -o subset.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c top.c -o top.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c trees.c -o trees.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c
update.c -o update.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c utility.c -o utility.o
gcc -m64 -std=gnu99 -I/usr/include/R -DNDEBUG -DNDEBUG -I/usr/local/include   -ffloat-store -g -fpic  -g -O2  -c xval.c -o xval.o
gcc -m64 -std=gnu99 -shared -L/usr/local/lib64 -o C50.so attwinnow.o classify.o confmat.o construct.o contin.o discr.o formrules.o formtree.o getdata.o getnames.o global.o hash.o hooks.o implicitatt.o info.o mcost.o modelfiles.o p-thresh.o prune.o rc50.o redefine.o rsample.o rulebasedmodels.o rules.o ruletree.o siftrules.o sort.o strbuf.o subset.o top.o trees.o update.o utility.o xval.o -L/usr/lib64/R/lib -lR
installing to /example/dbhome_1/R/library/C50/libs
** R
** data
** preparing package for lazy loading
** help
*** installing help indices
converting help for package 'C50'
finding HTML links ... done
C5.0                                    html
C5.0Control                             html
churn                                   html
predict.C5.0                            html
summary.C5.0                            html
varImp.C5.0                             html
** building package indices
** testing if installed package can be loaded
* DONE (C50)

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

この例では、C50パッケージをインストールするためのDLCIコマンドを示します。dcli -gフラグはインストール先のノードのリストを含むファイルを指定し、-lフラグはコマンドの実行時に使用するユーザーIDを指定します。DCLIの使用方法の詳細は、『Oracle R Enterpriseインストレーションおよび管理ガイド』を参照してください。

dcli -g nodes -l oracle R CMD INSTALL C50_0.1.0-19.tar.gz

例6-4 C50パッケージ関数の使用方法

この例では、Rを起動し、サーバー上のOracle R Enterpriseに接続して、C50パッケージをロードし、パッケージ内の関数を使用する方法を示します。この例では、LinuxコマンドラインからOREコマンドを実行してRを起動します。また、Oracle R Enterpriseに接続して、C50パッケージをロードします。demo関数を呼び出して、パッケージ内のサンプル・プログラムを検索します。このパッケージにはサンプルが含まれていないため、この例ではC5.0関数のヘルプを取得します。このヘルプからサンプル・コードを呼び出します。

ORE

library(ORE)
ore.connect(user = "RQUSER", sid = "orcl", host = "myhost",
password = "rquserStrongPassword", port = 1521, all=TRUE)

library(C50)
demo(package = "C50")
?C5.0
data(churn)
treeModel <- C5.0(x = churnTrain[, -20], y = churnTrain$churn)
treeModel
例6-4のリスト

$ ORE

R> library(ORE)
Loading required package: OREbase

Attaching package: 'OREbase'

The following objects are masked from 'package:base':

cbind, data.frame, eval, interaction, order, paste, pmax, pmin,
rbind, table

Loading required package: OREembed
Loading required package: OREstats
Loading required package: MASS
Loading required package: OREgraphics
Loading required package: OREeda
Loading required package: OREmodels
Loading required package: OREdm
Loading required package: lattice
Loading required package: OREpredict
Loading required package: ORExml

> ore.connect(user = "RQUSER", sid = "orcl", host = "myhost",
+             password = "rquserStrongPassword", port = 1521, all=TRUE)
Loading required package: ROracle
Loading required package: DBI

R> library(C50)
R> demo(package = "C50")
no demos found
R> ?C5.0     # Output not shown.
R> data(churn)
R> treeModel <- C5.0(x = churnTrain[, -20], y = churnTrain$churn)
R> treeModel
Call:
C5.0.default(x = churnTrain[, -20], y = churnTrain$churn)

Classification Tree
Number of samples: 3333
Number of predictors: 19

Tree size: 27

Non-standard options: attempt to group attributes

関連項目:

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

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

- 『R Administration and Installation Guide』(http://cran.r-project.org/doc/manuals/r-release/R-admin.html)

- http://www.r-bloggers.com/installing-r-packages/

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

Oracle R Enterpriseには、Oracle Databaseに埋め込まれている1つ以上のRエンジンで実行するRスクリプトを起動する関数があります。他には、R関数の作成およびスクリプトとしてのOracle R EnterpriseのRスクリプト・リポジトリへの格納、スクリプトへの読取りアクセス権の付与または取消し、使用可能なスクリプトのリスト、R環境へのスクリプト関数のロード、またはリポジトリからのスクリプトの削除を行う関数があります。この項では、次の各トピックでこれらの関数について説明します。

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

- R APIを使用したスクリプトの管理

- ore.doEval関数の使用方法

- ore.tableApply関数の使用方法

- ore.groupApply関数の使用方法

- ore.rowApply関数の使用方法

- ore.indexApply関数の使用方法

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

Oracle R Enterpriseの埋込みRの実行関数のore.doEval、ore.tableApply、ore.groupApply、ore.rowApplyおよびore.indexApplyには、これらの関数の一部またはすべてに共通の引数があります。一部の関数には、その関数に固有の引数もあります。

この項では、引数について次の各項で説明します。

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

- オプションの制御引数

- 戻り値の構造

- 入力データ

- パラレル実行

- 固有の引数

関連項目:

- 関数シグネチャおよび関数の引数の詳細は、help(ore.doEval)を呼び出すことで表示されるオンライン・ヘルプを参照してください。

- 引数の使用例は、「ore.doEval関数の使用方法」および埋込みRの実行関数の使用方法に関するその他のトピックを参照してください。

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

すべての埋込みRの実行関数には、スクリプトの実行時に適用するための関数が必要です。次の相互に排他的な引数のどちらかを使用して入力関数を指定します。

- FUN

- FUN.NAME (およびオプションのFUN.OWNER)

FUN引数は、関数オブジェクトを直接指定された関数としてまたはR変数に割り当てられた関数として使用します。RQADMINロールを持つユーザーのみが、埋込みR関数の呼出し時にFUN引数を使用できます。

FUN.NAME引数には、Oracle R EnterpriseのRスクリプト・リポジトリに格納されているスクリプトを指定します。格納されたスクリプトには、スクリプトの実行時に適用する関数が含まれます。すべてのOracle R Enterpriseユーザーが、埋込みR関数の呼出し時にFUN.NAME引数を使用できます。

オプションの引数FUN.OWNERには、Rスクリプト・リポジトリ内のスクリプトの所有者を指定します。所有者は、スクリプトを作成したユーザーです。この引数は、FUN.NAME引数とともにのみ使用します。FUN.NAMEが、読取りアクセス権を付与されているプライベート・スクリプトである場合は、FUN.OWNNERを使用して、プライベート・スクリプトの所有者を指定してください。

RQSYSスキーマは、パブリック・スクリプトおよび事前定義済のOracle R Enterpriseスクリプトの所有者です。事前定義済スクリプトのリストは、help("ore.doEval")を呼び出し、FUN.NAME引数の説明を参照してください。FUN.OWNNERが指定されていないか、NULLである場合、Oracle R Enterpriseによって、現行のセッションのユーザー、RQSYSの順に所有者が検索されます。スクリプトの所有者が現行のユーザーまたはRQSYSでない場合は、エラーが発生します。

注意:

OREmodelsパッケージのOracle R Enterpriseの高度な分析関数であるore.glm、ore.lm、ore.neuralおよびore.randomForestは、埋込みRの実行フレームワークを内部で使用し、埋込みRの実行関数では使用できません。

6.2.1.2 オプションの制御引数

すべての埋込みRの実行関数は、指定が可能または不可能なオプションの引数を取ります。Oracle R Enterpriseは、ユーザー定義のオプションの引数を入力関数に渡します。モデルなどの複合Rオブジェクトを含む入力関数に、任意の数のオプションの引数を渡すことができます。

ore.で始まる引数は、特殊な制御引数です。Oracle R Enterpriseはそれらを入力関数に渡しませんが、かわりに、それらを使用して入力関数の実行前または後に発生することを制御します。次の制御引数がサポートされます。

- ore.connectは、埋込みRの実行関数内でOracle R Enterpriseに自動的に接続するかどうかを制御します。これは、クライアント・セッションと同じ資格証明を指定してore.connectをコールすることと同等です。デフォルト値はFALSEです。
自動接続を有効にすると、次の機能を実現できます。

- 埋込みRスクリプトがデータベースに接続されます。

- 接続は、埋込みR SQL関数を呼び出すセッションと同じ資格証明を持ちます。

- このスクリプトは自律型トランザクション内で実行されます。

- ROracle問合せは自動接続と連携できます。

- Oracle R Enterprise透過層の機能が埋込みスクリプトで使用可能になります。

- ore.dropは入力データを制御します。オプション値がTRUEの場合、1列のdata.frameがvectorに変換されます。デフォルト値はTRUEです。

- ore.envAsEmptyenvは、シリアライズ中にオブジェクト内の参照される環境を空の環境で置き換えるかどうかを制御します。一部のタイプの入力パラメータおよび戻りオブジェクト(listやformulaなど)は、データベースに保存される前にシリアライズされます。制御引数の値がTRUEの場合、オブジェクト内の参照される環境は親が.GlobalEnvである空の環境で置き換えられ、参照される元の環境内のオブジェクトはシリアライズされません。これにより、シリアライズされるオブジェクトのサイズを大幅に削減できる場合があります。制御引数の値がFALSEの場合、参照される環境内のすべてのオブジェクトがシリアライズされますが、後からシリアライズ解除してリカバリすることができます。デフォルト値は、グローバル・オプションore.envAsEmptyenvによって決定されます。

- ore.na.omit入力データの欠損値の処理を制御します。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関数に標準のデフォルト値が使用されます。

関連項目:

制御引数の詳細は、help(ore.doEval)を呼び出すことで表示されるオンライン・ヘルプを参照してください。

6.2.1.3 戻り値の構造

すべての埋込み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.frameの対応する出力列がCLOBまたはBLOBデータベース・データ型を持つように指定するには、FUN.VALUE data.frameの列に属性ora.typeを適用できます。ora.typeの使用例は、例6-11を参照してください。

6.2.1.4 データの入力

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エンジンのメモリーにロードできません。

6.2.1.5 パラレル実行

ore.groupApply、ore.indexApplyおよびore.rowApplyの各関数は、parallel引数を取ります。この引数には、入力関数の埋込みRの実行で使用するための並列度を指定します。「パラレル実行のサポート」を参照してください。

6.2.1.6 固有の引数

関数ore.groupApply、ore.indexApplyおよびore.rowApplyは、それぞれの関数に固有の引数を取ります。

ore.groupApply関数はINDEX引数を取り、これには、入力データの行が入力関数での処理のためにパーティショニングされる列の名前を指定します。

ore.indexApply関数はtimes引数を取り、これには、入力関数を実行する回数を指定します。

ore.rowApply関数はrows引数を取り、これには、入力関数の各呼出しに渡す行の数を指定します。

6.2.2 Rでのスクリプトの管理

埋込みRの実行関数で、Oracle R EnterpriseのRスクリプト・リポジトリにスクリプトとして格納されているR関数を呼び出すことができます。このトピックで説明するR関数を使用すると、スクリプトを作成および管理できます。

「実行するための入力関数」に記載されているように、埋込みRの実行関数はFUN.NAME引数を取ることができます。その引数には、Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前を指定します。Rスクリプト・リポジトリ内のスクリプトは、埋込みRの実行用のSQL APIインタフェースで使用することもできます。

スクリプトを管理するためのR関数は次のとおりです。

- ore.grant

- ore.revoke

- ore.scriptCreate

- ore.scriptList

- ore.scriptLoad

- ore.scriptDrop

これらの関数については、次の各項で説明します。

- スクリプトの追加

- スクリプトへの読取りアクセス権の付与または取消し

- 使用可能なスクリプトのリスト

- R環境へのスクリプトのロード

- スクリプトの削除

これらの関数の使用例は、例6-5を参照してください。

スクリプトの追加

Oracle R EnterpriseのRスクリプト・リポジトリにスクリプトとしてR関数を追加するには、ore.createScript関数を使用します。この関数を呼び出すには、RQADMINロールを持っている必要があります。ore.createScript関数の構文は次のとおりです。

ore.scriptCreate(name, FUN, global, overwrite)

引数について、次に説明します。

引数

説明

name

Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前。

fun

R関数。

global

スクリプトがパブリック(グローバル)であるか、プライベートであるかを示す論理値。FALSE (デフォルト)は、スクリプトがパブリックではなく、所有者または所有者が読取りアクセス権を付与したユーザーにのみ表示されることを示します。TRUEは、スクリプトがパブリックであるため、すべてのユーザーに表示されることを示します。

overwrite

スクリプトのR関数を、fun引数で指定した関数に置き換えるかどうかを示す論理値。TRUEは、関数を置き換えることを示します(存在する場合)。FALSE (デフォルト)は、既存の内容を置き換えることができないことを示します。

overwrite = FALSEであるときに、同じ名前のスクリプトがRスクリプト・リポジトリにすでに存在する場合、エラー条件が発生します。それ以外の場合、ore.scriptCreateはNULLを返します。

スクリプトへの読取りアクセス権の付与または取消し

スクリプトの作成者は、ore.grant関数を使用してスクリプトへの読取りアクセス権を付与したり、ore.revoke関数を使用してそのアクセス権を取り消すことができます。これらの関数の構文は次のとおりです。

ore.grant(name, type = "rqscript", user)
ore.revoke(name, type = "rqscript", user)

引数について、次に説明します。

引数

説明

name

Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前。

type

スクリプトの場合、タイプはrqscriptです。

user

読取りアクセス権を付与する、または取り消すユーザー。

nameおよびtype引数は必須です。引数userを指定しなかった場合、読取りアクセス権がすべてのユーザーに付与されるか、すべてのユーザーから取り消されます。

次のいずれかに該当する場合、エラーが発生します。

- 指定したスクリプトがRスクリプト・リポジトリ内にありません。

- type引数が指定されていません。

- ユーザーが見つかりません。

- 読取り権限がすでにユーザーに付与されているか、ユーザーから取り消されています。

- 指定したスクリプトがパブリックです。

使用可能なスクリプトのリスト

自分が使用できるスクリプトをリストするには、ore.scriptListを使用します。名前、パターンまたはタイプに基づいてスクリプトをリストできます。RQADMINロールを持っている場合は、システム・スクリプトもリストできます。関数の構文は次のとおりです。

ore.sriptList(name, pattern, type)

引数について、次に説明します。

引数

説明

name

Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前。引数patternを指定する場合は使用できません。

pattern

正規表現パターン。パターンと一致するスクリプトがリストされます。引数nameを指定する場合は使用できません。

type

スクリプトのタイプとして、次のいずれかを指定できます。

- user: 現行のユーザーが所有しているスクリプトがリストされます。

- global: すべてのユーザーに表示されるパブリック・スクリプトがリストされます。

- grant: 現行のユーザーが他のユーザーに読取りアクセス権を付与したスクリプトがリストされます。

- granted: 現行のユーザーが別のユーザーによって読取りアクセス権を付与されたスクリプトがリストされます。

- all: ユーザーのスクリプト、パブリック・スクリプトおよびアクセス権を付与されたスクリプトがすべてリストされます。

ore.scriptList関数は、Rスクリプト・リポジトリ内のスクリプトおよびスクリプト内の関数の名前を含むdata.frameを返します。

R環境へのスクリプトのロード

R環境にスクリプトのR関数をロードするには、ore.scriptLoadを使用し、その構文は次のとおりです。

ore.sriptLoad(name, owner, newname, envir)

引数について、次に説明します。

引数

説明

name

Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前。

owner

スクリプトの所有者。

newname

スクリプトをロードする新しい関数名。

envir

スクリプトをロードするR環境。

ore.scriptLoadを呼び出すユーザーにスクリプトへのアクセス権が付与されている場合、スクリプトの所有者を指定すると便利です。

Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前が有効なR関数名でない場合、新しい関数名を指定すると便利です。

次のいずれかに該当する場合、エラーが発生します。

- スクリプトがRスクリプト・リポジトリ内にありません。

- 現行のユーザーにスクリプトへの読取りアクセス権がありません。

- name引数で指定した関数が有効なR関数名ではありません。

- newname引数が有効なR関数名ではありません。

スクリプトの削除

Oracle R EnterpriseのRスクリプト・リポジトリからスクリプトを削除するには、ore.scriptDrop関数を使用します。この関数を呼び出すには、RQADMINロールを持っている必要があります。ore.scriptDrop関数の構文は次のとおりです。

ore.scriptDrop(name, global, silent)

引数について、次に説明します。

引数

説明

name

Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前。

global

スクリプトがグローバル(パブリック)であるか、プライベートであるかを示す論理値。TRUEは、グローバル・スクリプトを削除することを示します。FALSE (デフォルト)は、現行のユーザーが所有しているスクリプトを削除することを示します。

silent

ore.scriptDropでエラー条件が検出された場合にエラー・メッセージを表示するかどうかを示す論理値。TRUEは、エラー・メッセージを表示することを示します。FALSE (デフォルト)は、表示しないことを示します。

次のいずれかに該当する場合、エラー条件が発生します。

- スクリプトがRスクリプト・リポジトリ内にありません。

- global = TRUEの場合に、スクリプトがプライベート・スクリプトです。

- global = FALSEの場合に、スクリプトがパブリック・スクリプトです。

成功すると、ore.scriptDropはNULLを返します。

例6-5 Rスクリプト管理関数の使用方法

# Create an ore.frame object from the data.frame for the iris data set.
IRIS <- ore.push(iris)

# Create a private R script for the current user.
ore.scriptCreate("myRandomRedDots", function(divisor = 100){
id <- 1:10
plot(1:100, rnorm(100), pch = 21, bg = "red", cex = 2 )
data.frame(id = id, val = id / divisor)
})

# Create another private R script.
ore.scriptCreate("MYLM",
function(data, formula, ...) lm(formula, data, ...))

# Create a public script, available to any user.
ore.scriptCreate("GLBGLM",
function(data, formula, ...)
glm(formula = formula, data = data, ...),
global = TRUE)

# List only my private scripts.
ore.scriptList()

# List my private scripts and the public scripts.
ore.scriptList(type = "all")

# List my private scripts that have the specified pattern.
ore.scriptList(pattern = "MY")

# Grant read access to a private script to all users.
ore.grant("MYLM", type = "rqscript")

# Grant read access to a private script to a specific user.
ore.grant("myRandomRedDots", user = "SCOTT",  type = "rqscript")

# List the granted scripts.
ore.scriptList(type = "grant")

# Use the MYLM script in an embedded R execution function.
ore.tableApply(IRIS[1:4], FUN.NAME = "MYLM",
formula = Sepal.Length ~ .)
# Use the GLBGLM script in an embedded R execution function.
ore.tableApply(IRIS[1:4], FUN.NAME = "GLBGLM",
formula = Sepal.Length ~ .)

# Load an R script to an R function object
ore.scriptLoad(name = "MYLM")

# Invoke the function.
MYLM(iris, formula = Sepal.Length ~ .)

# Load another R script to an R function object
ore.scriptLoad(name = "GLBGLM", newname = "MYGLM")

# Invoke the function.
MYGLM(iris, formula = Sepal.Length ~ .)

# Drop some scripts.
ore.scriptDrop("MYLM")
ore.scriptDrop("GLBGLM", global = TRUE)

# List all scripts.
ore.scriptList(type = "all")

例6-5のリスト

R> # Create an ore.frame object from the data.frame for the iris data set.
R> IRIS <- ore.push(iris)
R>
R> # Create a private R script for the current user.
R> ore.scriptCreate("myRandomRedDots", 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>
R> # Create another private R script.
R> ore.scriptCreate("MYLM",
+                   function(data, formula, ...) lm(formula, data, ...))
R>
R> # Create a public script, available to any user.
R> ore.scriptCreate("GLBGLM",
+                   function(data, formula, ...)
+                   glm(formula = formula, data = data, ...),
+                   global = TRUE)
R>
R> # List only my private scripts.
R> ore.scriptList()
NAME      SCRIPT
1            MYLM      function (data, formula, ...) \nlm(formula, data, ...)
2 myRandomRedDots      function (divisor = 100) \n{\n    id & lt\n    -1:10\n
plot(1:100, rnorm(100), pch = 21, bg = "red", cex = 2)\n
data.frame(id = id, val = id/divisor)\n}
R>
R> # List my private scripts and the public scripts.
R> ore.scriptList(type = "all")
OWNER            NAME      SCRIPT
1  RQSYS          GLBGLM      function (data, formula, ...) \nglm(formula = formula, data = data, ...)
2 RQUSER            MYLM      function (data, formula, ...) \nlm(formula, data, ...)
3 RQUSER myRandomRedDots      function (divisor = 100) \n{\n    id & lt\n    -1:10\n
plot(1:100, rnorm(100), pch = 21, bg = "red", cex = 2)\n
data.frame(id = id, val = id/divisor)\n}
R>
R> # List my private scripts that have the specified pattern.
R> ore.scriptList(pattern = "MY")
NAME  SCRIPT
1 MYLM  function (data, formula, ...) \nlm(formula, data, ...)
R>
R> # Grant read access to a private script to all users.
R> ore.grant("MYLM", type = "rqscript")
R>
R> # Grant read access to a private script to a specific user.
R> ore.grant("myRandomRedDots", user = "SCOTT",  type = "rqscript")
R>
R> # List the granted scripts.
R> ore.scriptList(type = "grant")
NAME GRANTEE
1            MYLM  PUBLIC
2 myRandomRedDots   SCOTT
R>
R> # Use the MYLM script in an embedded R execution function.
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>
R> # Use the GLBGLM script in an embedded R execution function.
R> ore.tableApply(IRIS[1:4], FUN.NAME = "GLBGLM",
+                formula = Sepal.Length ~ .)

Call:  glm(formula = formula, data = data)

Coefficients:
(Intercept)   Sepal.Width  Petal.Length   Petal.Width
1.8560        0.6508        0.7091       -0.5565

Degrees of Freedom: 149 Total (i.e. Null);  146 Residual
Null Deviance:      102.2
Residual Deviance: 14.45        AIC: 84.64
R>
R> # Load an R script to an R function object
R> ore.scriptLoad(name="MYLM")
R>
R> # Invoke the function.
R> MYLM(iris, formula = Sepal.Length ~ .)
R>
R> # Load another R script to an R function object
R> ore.scriptLoad(name = "GLBGLM", newname = "MYGLM")
R>
R> # Invoke the function.
R> MYGLM(iris, formula = Sepal.Length ~ .)
R>
R> # Drop some scripts.
R> ore.scriptDrop("MYLM")
R> ore.scriptDrop("GLBGLM", global = TRUE)
R>
R> # List all scripts.
R> ore.scriptList(type = "all")
OWNER             NAME    SCRIPT
RQUSER  myRandomRedDots    function (divisor = 100) \n{\n    id & lt\n    -1:10\n
plot(1:100, rnorm(100), pch = 21, bg = "red", cex =
2)\n data.frame(id = id, val = id/divisor)\n}

関連項目:

- myRandomRedDotsスクリプトの使用例は、「ore.doEval関数の使用方法」を参照してください。

- ore.scriptCreateおよびore.scriptDropの他の使用例は、例6-14を参照してください。

- 「SQLでのスクリプトの管理」

6.2.3 ore.doEval関数の使用方法

ore.doEval関数は、入力関数によって生成されたデータを使用して指定された入力関数を実行します。ore.frameオブジェクトまたはシリアライズRオブジェクトをore.objectオブジェクトとして返します。

ore.doEval関数の構文は次のとおりです。

ore.doEval(FUN, ..., FUN.VALUE = NULL, FUN.NAME = NULL, FUN.OWNER = NULL)

関連項目:

関数ore.doEvalの引数の詳細は、「スクリプトを実行する関数の引数」を参照してください。

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

この例では、RandomRedDotsによって、1つの引数を取り、2つの列を持つdata.frameオブジェクトを返し、100個のランダム標準値を表示する関数を取得します。次に、ore.doEval関数を呼び出して、RandomRedDots functionオブジェクトを渡します。イメージがクライアントに表示されますが、これはRandomRedDots関数を実行したデータベース・サーバーの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)
}
ore.doEval(RandomRedDots)
例6-6のリスト

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 ランダムの赤い点の表示

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

doEval関数のオプションの引数として入力関数に引数を指定できます。この例では、RandomRedDots関数のdivisor引数をオーバーライドするオプションの引数を指定してdoEval関数を呼び出します。

ore.doEval(RandomRedDots, divisor = 50)
例6-7のリスト

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.

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

入力関数がOracle R EnterpriseのRスクリプト・リポジトリに格納されている場合は、FUN.NAME引数を指定してore.doEval関数を呼び出すことができます。この例ではまず、myRandomRedDotsという名前のスクリプトがRスクリプト・リポジトリに含まれないようにするために、ore.scriptDropを呼び出します。この例では、例6-6のRandomRedDots関数をmyRandomRedDotsという名前でリポジトリに追加します。この例では、ore.doEval関数を呼び出し、myRandomRedDotsを指定します。結果は変数resに割り当てられます。

RandomRedDots関数の戻り値はdata.frameですが、この例では、ore.doEval関数はore.objectオブジェクトを返します。data.frameオブジェクトを取得するために、ore.pullを呼び出して結果をクライアントのRセッションにプルします。

ore.scriptDrop("myRandomRedDots")
ore.scriptCreate("myRandomRedDots", RandomRedDots)
res <- ore.doEval(FUN.NAME = "myRandomRedDots", divisor = 50)
class(res)
res.local <- ore.pull(res)
class(res.local)
例6-8のリスト

R> ore.scriptDrop("myRandomRedDots")
R> ore.scriptCreate("myRandomRedDots", RandomRedDots)
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"

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

doEval関数でore.objectではなくore.frameオブジェクトが返されるようにするには、この例に示すように、引数FUN.VALUEを使用して結果の構造を指定します。

res.of <- ore.doEval(FUN.NAME="myRandomRedDots", divisor = 50,
FUN.VALUE= data.frame(id = 1, val = 1))
class(res.of)
例6-9のリスト

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"

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

この例では、特殊なオプションの引数ore.connectを使用して埋込みR関数でデータベースに接続することにより、データストアに格納されているオブジェクトを使用できるようにする方法を示します。この例では、RandomRedDots2関数オブジェクト(例6-6のRandomRedDots関数と似ているが、RandomRedDots2関数はデータストア名を指定する引数を取る)を作成します。この例では、myVar変数を作成して、datastore_1という名前のデータストアに保存します。次に、doEval関数を呼び出してデータストア名を渡し、TRUEに設定したore.connect制御引数を渡します。

RandomRedDots2 <- 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 the numeric variable myVar.
data.frame(id = id, val = id / divisor, num = myVar)
}
myVar <- 5
ore.save(myVar, name = "datastore_1")
ore.doEval(RandomRedDots2, datastore.name = "datastore_1", ore.connect = TRUE)
例6-10のリスト

R> RandomRedDots2 <- 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 the numeric variable myVar.
+   data.frame(id = id, val = id / divisor, num = myVar)
+ }
R> ore.doEval(RandomRedDots2, 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.

例6-11 ora.type属性の使用方法

この例では、ora.type属性を使用して、FUN.VALUE引数で指定されたdata.frameオブジェクト内の列にデータベース・データ型のCLOBおよびBLOBを指定する方法を示します。

eval1 <- ore.doEval(function() "Hello, world")
eval2 <-
ore.doEval(function()
data.frame(x = "Hello, world", stringsAsFactors = FALSE))
eval3 <-
ore.doEval(function()
data.frame(x = "Hello, world", stringsAsFactors = FALSE),
FUN.VALUE =
data.frame(x = character(), stringsAsFactors = FALSE))
out.df <- data.frame(x = character(), y = raw(), stringsAsFactors = FALSE)
attr(out.df$x, "ora.type") <- "clob"
attr(out.df$y, "ora.type") <- "blob"
eval4 <-
ore.doEval(function() {
res <- data.frame(x = "Hello, world",stringsAsFactors = FALSE)
res$y[[1L]] <- charToRaw("Hello, world")
res},
FUN.VALUE = out.df)
eval1
class(eval1)  # ore.object
eval2
class(eval2)  # ore.object
eval3
class(eval3)  # ore.frame
eval4$x
rawToChar(ore.pull(eval4$y))

例6-11のリスト

R> eval1 <- ore.doEval(function() "Hello, world")
R> eval2 <-
+    ore.doEval(function()
+               data.frame(x = "Hello, world", stringsAsFactors = FALSE))
R> eval3 <-
+    ore.doEval(function()
+               data.frame(x = "Hello, world", stringsAsFactors = FALSE),
+               FUN.VALUE =
+               data.frame(x = character(), stringsAsFactors = FALSE))
R> out.df <- data.frame(x = character(), y = raw(), stringsAsFactors = FALSE)
R> attr(out.df$x, "ora.type") <- "clob"
R> attr(out.df$y, "ora.type") <- "blob"
R> eval4 <-
+    ore.doEval(function() {
+               res <- data.frame(x = "Hello, world",stringsAsFactors = FALSE)
+               res$y[[1L]] <- charToRaw("Hello, world")
+               res},
+               FUN.VALUE = out.df)
R> eval1
[1] "Hello, world"
R> class(eval1)
[1] "ore.object"
attr(,"package")
[1] "OREembed"
R> eval2
x
1 Hello, world
R> class(eval2)
[1] "ore.object"
attr(,"package")
[1] "OREembed"
R> eval3
x
1 Hello, world
Warning message:
ORE object has no unique key - using random order
R> class(eval3)
[1] "ore.frame"
attr(,"package")
[1] "OREbase"
R> eval4$x
[1] "Hello, world"
Warning message:
ORE object has no unique key - using random order
R> rawToChar(ore.pull(eval4$y))
[1] "Hello, world"
Warning message:
ORE object has no unique key - using random order

6.2.4 ore.tableApply関数の使用方法

ore.tableApply関数は、入力データとしてore.frameを指定してRスクリプトを起動します。ore.tableApply関数は、ore.frameを最初の引数としてユーザー定義の入力関数に渡します。ore.tableApply関数は、ore.frameオブジェクトまたはシリアライズRオブジェクトをore.objectオブジェクトとして返します。

ore.tableApply関数の構文は次のとおりです。

ore.tableApply(X, FUN, ..., FUN.VALUE = NULL, FUN.NAME = NULL, FUN.OWNER = NULL)

関連項目:

- 関数ore.tableApplyの引数の詳細は、「スクリプトを実行する関数の引数」を参照してください。

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

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

この例では、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オブジェクトとして返すモデルを作成します。

library(e1071)
nbmod <- ore.tableApply(
ore.push(iris),
function(dat) {
library(e1071)
dat$Species <- as.factor(dat$Species)
naiveBayes(Species ~ ., dat)
})
class(nbmod)
nbmod
例6-12のリスト

R> nbmod <- ore.tableApply(
+   ore.push(iris),
+   function(dat) {
+     library(e1071)
+     dat$Species <- as.factor(dat$Species)
+     naiveBayes(Species ~ ., dat)
+ })
R> class(nbmod)
[1] "ore.object"
attr(,"package")
[1] "OREembed"
R> nbmod

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

6.2.5 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.groupApply(X, INDEX, FUN, ..., FUN.VALUE = NULL, FUN.NAME = NULL, FUN.OWNER = NULL,
parallel = getOption("ore.parallel", NULL))

ore.groupApply関数は、ore.listオブジェクトまたはore.frameオブジェクトを返します。

ore.groupApply関数の使用例は、次の各項で説明します。

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

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

関連項目:

- 関数ore.groupApplyの引数の詳細は、「スクリプトを実行する関数の引数」を参照してください。

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

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

例6-13では、ディシジョン・ツリーおよびルールベース・モデルを構築する関数が含まれるC50パッケージを使用します。このパッケージには、トレーニング・データとテスト・データのセットも含まれています。例6-13では、状態ごとのデータに基づいて1つのチャーン・モデルを作成することを目的に、C50パッケージのchurnデータセットからのchurnTrainトレーニング・データセットに基づいてC5.0モデルを構築します。この例では、次の操作を実行しています。

- C50パッケージをロードした後に、churnデータセットをロードします。

- ore.create関数を使用して、churnTrain (data.frameオブジェクト)からCHURN_TRAINデータベース表およびそのプロキシore.frameオブジェクトを作成します。

- CHURN_TRAIN (プロキシore.frameオブジェクト)をore.groupApply関数の最初の引数として指定し、state列をINDEX引数として指定します。ore.groupApply関数は、state列のデータをパーティショニングし、ユーザー定義の関数を各パーティションで呼び出します。

- ore.groupApply関数によって返されるore.listオブジェクトを取得するための変数modListを作成します。ore.listオブジェクトには、データの各パーティションでユーザー定義の関数を実行した結果が含まれています。この場合は、状態ごとに1つのC5.0モデルで、各モデルはore.objectオブジェクトとして格納されています。

- ユーザー定義の関数を指定します。ユーザー定義の関数の最初の引数は、データ(1つの状態に関連付けられたすべてのデータ)の1つのパーティションを受け取ります。
ユーザー定義の関数は、次のことを実行します。

- データベースのRエンジンで起動したときに関数で使用できるように、C50パッケージをロードします。

- state列がモデルに含まれないように、data.frameからこの列を削除します。

- ore.frameはファクタを定義しますが、ユーザー定義の関数にロードされたときにファクタが文字列ベクターとして表示されるため、列をファクタに変換します。

- 状態のモデルを構築し、それを返します。

- ore.pull関数を使用してデータベースからmod.MA変数としてモデルを取得し、そこでsummary関数を呼び出します。mod.MAのクラスはC5.0です。

例6-13 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-13のリスト

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

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

ore.groupApply関数は、INDEX引数として1つの列または複数の列を取ります。

例6-14は、CHURN_TRAINデータセットのデータを使用して、指定したデータのパーティション(voice_mail_plan列およびinternational_plan列)に対するルールを作成するrpartモデルを構築します。この例では、Rのtable関数を使用して各パーティションで予測される行の数を示します。

この例では次に、指定された名前のスクリプトがOracle DatabaseのRスクリプト・リポジトリに存在しないようにするために、ore.scriptDrop関数を呼び出します。その後、ore.scriptCreate関数を使用してmy_rpartFunctionという名前のスクリプトを定義し、それをリポジトリに格納します。格納されたスクリプトでは、Oracle R Enterpriseのデータストア・オブジェクトの命名に使用されるデータ・ソースおよび接頭辞を使用する関数を定義します。関数my_rpartFunctionの各呼出しは、voice_mail_planおよびinternational_plan列の値によって特定されたパーティションのいずれかからデータを受け取ります。ソース・パーティションの列は定数のため、この関数はそれらをNULLに設定します。文字列ベクターをファクタに変換し、流動を予測するためのモデルを構築し、そこに適切に命名されたデータストアを保存します。この関数は、特定のパーティション列値、流動値の分布およびモデル自身を返すためのリストを作成します。

次にrpartライブラリをロードし、データストアの接頭辞を設定し、INDEX引数としてvoice_mail_planおよびinternational_plan列の値を、Rスクリプト・リポジトリに格納されているユーザー定義関数を呼び出すためのFUN.NAME引数の値としてmy_rpartFunctionを使用して、ore.groupApplyを呼び出します。ore.groupApply関数は、オプションの引数を使用してdatastorePrefix変数をユーザー定義の関数に渡します。この関数は、ユーザー定義の関数の実行時に、オプションの引数ore.connectを使用してデータベースに接続します。ore.groupApply関数は、変数resとしてore.listオブジェクトを返します。

この例では、返されるリストの最初のエントリを表示します。次に、ore.load関数を呼び出して、顧客がボイス・メール・プランと国際プランの両方を持つ場合のモデルをロードします。

例6-14 複数列でデータをパーティションする場合の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)

options(width = 80)
head(CHURN_TRAIN, 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(CHURN_TRAIN,
INDEX = CHURN_TRAIN[, c("voice_mail_plan", "international_plan")],
FUN.NAME = "my_rpartFunction",
datastorePrefix = datastorePrefix,
ore.connect = TRUE)
res[[1]]
ore.load(name=paste(datastorePrefix, "yes", "yes", sep = "_"))
mod
例6-14のリスト

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>
R> options(width = 80)
R> head(CHURN_TRAIN, 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
1              2.70                             1    no
2              3.70                             1    no
3              3.29                             0    no
Warning messages:
1: ORE object has no unique key - using random order
2: ORE object has no unique key - using random order
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(CHURN_TRAIN,
+       INDEX = CHURN_TRAIN[, c("voice_mail_plan", "international_plan")],
+       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) *

6.2.6 ore.rowApply関数の使用方法

ore.rowApply関数は、入力データとしてore.frameを指定してRスクリプトを起動します。ore.rowApply関数は、ore.frameを最初の引数としてユーザー定義の入力関数に渡します。ore.rowApply関数に対するrows引数には、ユーザー定義のR関数の呼出しごとに渡す行の数を指定します。最後のチャンクまたは行は、指定した数より少なくなる可能性があります。ore.rowApply関数は、1つ以上のRエンジンが同じR関数(タスク)をデータの別のパーティションで実行するデータ・パラレル実行を使用できます。

ore.rowApply関数の構文は次のとおりです。

ore.rowApply(X, FUN, ..., FUN.VALUE = NULL, FUN.NAME = NULL, rows = 1, FUN.OWNER = NULL,
parallel = getOption("ore.parallel", NULL))

ore.rowApply関数は、ore.listオブジェクトまたはore.frameオブジェクトを返します。

関連項目:

- 関数ore.rowApplyの引数の詳細は、「スクリプトを実行する関数の引数」を参照してください。

例6-15では、事前にCRANからダウンロードしてあるe1071パッケージを使用します。また、この例では、例6-12で作成したNaive Bayesモデルであるnbmodオブジェクトも使用します。

例6-15では、次の処理を行います。

- パッケージe1071をロードします。

- irisデータセットをIRIS一時表およびore.frameオブジェクトとしてデータベースにプッシュします。

- IRISをIRIS_PREDとしてコピーし、予測を含めるためにPRED列をIRIS_PREDに追加します。

- ore.rowApply関数を呼び出し、IRIS ore.frameをユーザー定義R関数のデータソースおよびユーザー定義R関数自体として渡します。

- ユーザー定義の関数は、次のことを実行します。

- パッケージe1071を、データベース内で稼働するRエンジンまたはエンジンで使用できるようにロードします。

- ore.frameはファクタを定義しますが、ユーザー定義の関数にロードされたときにファクタが文字列ベクターとして表示されるため、Species列をファクタに変換します。

- predictメソッドを起動し、データセットに追加された列に予測が含まれているresオブジェクトを返します。

- この例では、モデルをクライアントのRセッションにプルします。

- IRIS_PREDを引数FUN.VALUEとして渡しますが、この引数にore.rowApply関数が返すオブジェクトの構造を指定します。

- ユーザー定義関数の呼出しごとに渡す行の数を指定します。

- resのクラスを表示し、table関数を呼び出してSpecies列およびresオブジェクトのPRED列を表示します。

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

library(e1071)
IRIS <- ore.push(iris)
IRIS_PRED <- IRIS
IRIS_PRED$PRED <- "A"
res <- ore.rowApply(
IRIS,
function(dat, nbmod) {
library(e1071)
dat$Species <- as.factor(dat$Species)
dat$PRED <- predict(nbmod, newdata = dat)
dat
},
nbmod = ore.pull(nbmod),
FUN.VALUE = IRIS_PRED,
rows = 10)
class(res)
table(res$Species, res$PRED)
例6-15のリスト

R> library(e1071)
R> IRIS <- ore.push(iris)
R> IRIS_PRED <- IRIS
R> IRIS_PRED$PRED <- "A"
R> res <- ore.rowApply(
+   IRIS ,
+   function(dat, nbmod) {
+     library(e1071)
+     dat$Species <- as.factor(dat$Species)
+     dat$PRED <- predict(nbmod, newdata = dat)
+     dat
+   },
+   nbmod = ore.pull(nbmod),
+   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

例6-16では、例6-13と同様にC50パッケージを使用し、C5.0モデルを使用してチャーン・データをスコアリングします(つまり、解約傾向が高い顧客を予測します)。ただし、例6-16では、列によってデータをパーティショニングするのではなく、多数の行によってデータをパーティショニングします。この例では、指定された状態からの顧客を並行してスコアリングします。データストアを使用し、関数をOracle R EnterpriseのRスクリプト・リポジトリに保存することにより、これらの関数をOracle R Enterprise SQL API関数で使用できるようにします。

例6-16ではまず、C50パッケージおよびデータセットをロードします。この例では、名前にmyC5.0modelFLが含まれるデータストアが存在する場合、そのデータストアを削除します。ore.dropを呼び出してCHURN_TEST表(存在する場合)を削除した後、ore.createを呼び出してchurnTestデータセットからCHURN_TEST表を作成します。

次に、ファクタ列ごとにレベルのlistを返すore.getLevelsを呼び出します。この呼出しでは、最初の列(state)のレベルは必要ないため最初の列は除外されます。最初にレベルを取得しておくと、モデル構築中に、一部のレベルに対して値を持たない行があっても、すべての使用可能なレベルを確実に取得できます。ore.deleteの呼出しによって、指定された名前のデータストアが存在しないことが確認され、ore.saveの呼出しによって、xlevelsオブジェクトがmyXLevelsという名前のデータストアに保存されます。

例6-16では、C5.0モデルを生成するユーザー定義関数myC5.0FunctionForLevelsを作成します。この関数は、例6-13のようにas.factor関数をユーザー定義関数として使用してレベルを計算するのではなく、関数ore.getXlevelsにより返されたレベルのリストを使用します。レベルを使用して、列タイプを文字ベクターからファクタに変換します。関数myC5.0FunctionForLevelsは、値TRUEを返します。この例では、この関数をOracle R EnterpriseのRスクリプト・リポジトリに保存します。

次に、指定された文字列を含む名前のデータストアのリストを取得し、これらのデータストアが存在していれば削除します。

その後、ore.groupApplyを呼び出し、それによってCHURN_TESTデータの各状態に対して関数myC5.0FunctionForLevelsが呼び出されます。myC5.0FunctionForLevelsの呼出しのたびに、ore.groupApplyは、xlevelsオブジェクトを含むデータストアと、myC5.0FunctionForLevelsにより生成されたデータストアのネーミングに使用する接頭辞を渡します。また、ore.connect制御引数を渡して埋込みR関数でデータベースに接続することにより、データストアに格納されているオブジェクトを使用できるようにします。ore.groupApplyの呼出しにより、myC5.0FunctionForLevelsのすべての呼出しの結果を含むリストが返されます。

この例では、結果をローカルなRセッションにプルし、データソース内の各状態に対してmyC5.0FunctionForLevelsがTRUEを返したことを確認します。

例6-16では次に、別のユーザー定義関数myScoringFunctionを作成し、Oracle R EnterpriseのRスクリプト・リポジトリに格納します。この関数は、状態のレベルでC5.0モデルをスコアリングし、結果をdata.frameで返します。

次に、関数ore.rowApplyを呼び出します。マサチューセッツ州のデータのみを使用するように入力データをフィルタ処理します。呼び出す関数としてmyScoringFunctionを指定し、xlevelsオブジェクトを含むデータストアの名前と、状態に対するC5.0モデルを含むデータストアをロードする際に使用する接頭辞をそのユーザー定義関数に渡します。ore.rowApplyの呼出しにより、各パラレルRエンジンでデータセット200行に対してmyScoringFunctionを呼び出すことを指定します。ore.rowApplyがmyScoringFunctionのすべての呼出しの結果を含むore.frameを返すように、FUN.VALUE引数を使用します。変数scoresは、ore.rowApply呼出しの結果を取得します。

例6-16では最後に、scoresオブジェクトを出力した後、表関数を使用してスコアリング用の混同マトリクスを表示します。

関連項目:

例6-16のore.rowApply関数と同じ結果を生成するrqRowEval関数の呼出しは、例A-8を参照してください。

例6-16 データストアおよびスクリプトを指定したore.rowApply関数の使用方法

library(C50)
data(churn)

ore.drop("CHURN_TEST"
ore.create(churnTest, "CHURN_TEST")

xlevels <- ore.getXlevels(~ ., CHURN_TEST[,-1])
ore.delete("myXLevels")
ore.save(xlevels, name = "myXLevels")

ore.scriptDrop("myC5.0FunctionForLevels")
ore.scriptCreate("myC5.0FunctionForLevels",
function(dat, xlevelsDatastore, datastorePrefix) {
library(C50)
state <- dat[1,"state"]
datastoreName <- paste(datastorePrefix, dat[1, "state"], sep = "_")
dat$state <- NULL
ore.load(name = xlevelsDatastore)
for (j in names(xlevels))
dat[[j]] <- factor(dat[[j]], levels = xlevels[[j]])
c5mod <- C5.0(churn ~ ., data = dat, rules = TRUE)
ore.save(c5mod, name = datastoreName)
TRUE
})

ds.v <- ore.datastore(pattern= "myC5.0modelFL")$datastore.name
for (ds in ds.v) ore.delete(name = ds)

res <- ore.groupApply(CHURN_TEST,
INDEX=CHURN_TEST$state,
FUN.NAME = "myC5.0FunctionForLevels",
xlevelsDatastore = "myXLevels",
datastorePrefix = "myC5.0modelFL",
ore.connect = TRUE)
res <- ore.pull(res)
all(as.logical(res) == TRUE)

ore.scriptDrop("myScoringFunction")
ore.scriptCreate("myScoringFunction",
function(dat, xlevelsDatastore, datastorePrefix) {
library(C50)
state <- dat[1,"state"]
datastoreName <- paste(datastorePrefix,state,sep="_")
dat$state <- NULL
ore.load(name = xlevelsDatastore)
for (j in names(xlevels))
dat[[j]] <- factor(dat[[j]], levels = xlevels[[j]])
ore.load(name = datastoreName)
res <- data.frame(pred = predict(c5mod, dat, type = "class"),
actual = dat$churn,
state = state)
res
}
)

scores <- ore.rowApply(
CHURN_TEST[CHURN_TEST$state == "MA",],
FUN.NAME = "myScoringFunction",
xlevelsDatastore = "myXLevels",
datastorePrefix = "myC5.0modelFL",
ore.connect = TRUE, parallel = TRUE,
FUN.VALUE = data.frame(pred = character(0),
actual = character(0),
state = character(0)),
rows=200)
scores
table(scores$actual, scores$pred)

例6-16のリスト

R> library(C50)
R> data(churn)
R>
R> ore.drop("CHURN_TEST"
R> ore.create(churnTest, "CHURN_TEST")
R>
R> xlevels <- ore.getXlevels(~ ., CHURN_TEST[,-1])
R> ore.delete("myXLevels")
[1] "myXLevels
R> ore.save(xlevels, name = "myXLevels")
R>
R> ore.scriptDrop("myC5.0FunctionForLevels")
R> ore.scriptCreate("myC5.0FunctionForLevels",
+    function(dat, xlevelsDatastore, datastorePrefix) {
+      library(C50)
+      state <- dat[1,"state"]
+      datastoreName <- paste(datastorePrefix, dat[1, "state"], sep = "_")
+      dat$state <- NULL
+      ore.load(name = xlevelsDatastore)
+      for (j in names(xlevels))
+        dat[[j]] <- factor(dat[[j]], levels = xlevels[[j]])
+      c5mod <- C5.0(churn ~ ., data = dat, rules = TRUE)
+      ore.save(c5mod, name = datastoreName)
+      TRUE
+    })
R>
R> ds.v <- ore.datastore(pattern="myC5.0modelFL")$datastore.name
R> for (ds in ds.v) ore.delete(name=ds)
R>
R> res <- ore.groupApply(CHURN_TEST,
+                       INDEX=CHURN_TEST$state,
+                       FUN.NAME="myC5.0FunctionForLevels",
+                       xlevelsDatastore = "myXLevels",
+                       datastorePrefix = "myC5.0modelFL",
+                       ore.connect = TRUE)
R> res <- ore.pull(res)
R> all(as.logical(res) == TRUE)
[1] TRUE
R>
R> ore.scriptDrop("myScoringFunction")
R> ore.scriptCreate("myScoringFunction",
+                    function(dat, xlevelsDatastore, datastorePrefix) {
+                      library(C50)
+                      state <- dat[1,"state"]
+                      datastoreName <- paste(datastorePrefix,state,sep="_")
+                      dat$state <- NULL
+                      ore.load(name = xlevelsDatastore)
+                      for (j in names(xlevels))
+                          dat[[j]] <- factor(dat[[j]], levels = xlevels[[j]])
+                      ore.load(name = datastoreName)
+                      res <- data.frame(pred = predict(c5mod, dat, type="class"),
+                                        actual = dat$churn,
+                                        state = state)
+                      res
+                  }
+ )
R>
R> scores <- ore.rowApply(
+     CHURN_TEST[CHURN_TEST$state =="MA",],
+     FUN.NAME = "myScoringFunction",
+     xlevelsDatastore = "myXLevels",
+     datastorePrefix = "myC5.0modelFL",
+     ore.connect = TRUE, parallel = TRUE,
+     FUN.VALUE = data.frame(pred=character(0),
+                            actual=character(0),
+                            state=character(0)),
+     rows=200
R>
R> scores
pred actual state
1    no     no    MA
2    no     no    MA
3    no     no    MA
4    no     no    MA
5    no     no    MA
6    no    yes    MA
7   yes    yes    MA
8   yes    yes    MA
9    no     no    MA
10   no     no    MA
11   no     no    MA
12   no     no    MA
13   no     no    MA
14   no     no    MA
15  yes    yes    MA
16   no     no    MA
17   no     no    MA
18   no     no    MA
19   no     no    MA
20   no     no    MA
21   no     no    MA
22   no     no    MA
23   no     no    MA
24   no     no    MA
25   no     no    MA
26   no     no    MA
27   no     no    MA
28   no     no    MA
29   no    yes    MA
30   no     no    MA
31   no     no    MA
32   no     no    MA
33  yes    yes    MA
34   no     no    MA
35   no     no    MA
36   no     no    MA
37   no     no    MA
38   no     no    MA
Warning message:
ORE object has no unique key - using random order
R> table(scores$actual, scores$pred)

no yes
no  32   0
yes  2   4

6.2.7 ore.indexApply関数の使用方法

ore.indexApply関数は、入力関数によって生成されたデータを使用して指定されたユーザー定義の入力関数を実行します。これは、1つ以上のRエンジンが同じまたは異なる計算(タスク)を実行するタスク・パラレル実行をサポートします。ore.indexApply関数に対するtimes引数には、データベース内で入力関数を実行する回数を指定します。必要なすべてのデータは、入力関数内で明示的に生成またはロードされる必要があります。

ore.indexApply関数の構文は次のとおりです。

ore.indexApply(times, FUN, ..., FUN.VALUE = NULL, FUN.NAME = NULL, FUN.OWNER = NULL,
parallel = getOption("ore.parallel", NULL))

ore.indexApply関数は、ore.listオブジェクトまたはore.frameオブジェクトを返します。

ore.indexApply関数の使用例は、次の各項で説明します。

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

- 「列並行の使用例」

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

関連項目:

- 関数ore.indexApplyの引数の詳細は、「スクリプトを実行する関数の引数」を参照してください。

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

例6-17では、ore.indexApplyを呼び出し、入力関数を並行して5回実行することを指定します。結果のクラスであるore.listを表示した後に、結果を表示します。

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

res <- ore.indexApply(5,
function(index) {
paste("IndexApply:", index)
},
parallel = TRUE)
class(res)
res
例6-17のリスト

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.2.7.2 列並行の使用例

例6-18では、Rのsummary関数を使用して、irisデータセットの最初の4つの数値列でサマリー統計を並行して計算します。この例では、計算を最終結果に結合します。ore.indexApply関数の最初の引数は4で、これは、並行してまとめる列の数を指定します。ユーザー定義の入力関数は1つの引数indexを取り、これは、まとめる列を指定する1から4の値です。

この例では、summary関数を指定した列で呼び出します。summaryの呼出しでは、列のサマリー統計が含まれている単一の行が返されます。この例では、summary呼出しの結果をdata.frameに変換し、そこに列名を追加します。

次に、ore.indexApply関数に対してFUN.VALUE引数を使用して、関数の結果の構造を定義します。結果はその後、その構造とともにore.frameオブジェクトとして返されます。

例6-18 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-18のリスト

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

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

ore.indexApply関数をシミュレーションで使用しすることで、Oracle Exadataデータベース・マシンなどの高パフォーマンスのコンピューティング・ハードウェアを利用できます。例6-19は、ランダムな正規分布の複数のサンプルを使用してサマリー統計の分布を比較します。各シミュレーションは、データベースの別個のRエンジンで、データベースで許可された並列度まで並列に実行されます。

例6-19では、サンプル・サイズの変数、乱数値の平均および標準偏差および実行するシミュレーションの数を定義します。この例では、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-19 シミュレーションでの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-19のリスト

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-19でのboxplot関数の表示

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

Oracle R Enterpriseの埋込みRの実行用のSQLインタフェースでは、本番データベースのアプリケーションでR関数を実行できます。SQLインタフェースには、次のアクションのためのプロシージャがあります。

- Oracle R EnterpriseのRスクリプト・リポジトリに対するスクリプトの追加および削除

- 所有者による他のユーザーに対するスクリプトへの読取りアクセス権の付与または取消し

- 埋込みRセッションでのRスクリプトの実行

- Oracle R Enterpriseデータストアの削除

データ・ディクショナリ・ビューは、スクリプトおよびデータストアに関する情報を提供します。

このSQLインタフェースについては、次のトピックで説明しています。

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

- SQLでのスクリプトの管理

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

- rqEval関数

- rqGroupEval関数

- rqRowEval関数

- rqTableEval関数

6.3.1 Oracle R EnterpriseのSQL表関数について

Oracle R Enterpriseでは、埋込みRの実行用のRインタフェース関数のほとんどに相当するSQL表関数が提供されています。SELECT FROM TABLE文を実行し、いずれかの表関数を指定すると、指定されたRスクリプトが呼び出されます。このスクリプトは、Oracle Databaseサーバー上の1つ以上のRエンジンで実行されます。

埋込みRの実行用のSQL表関数は次のとおりです。

- rqEval

- rqGroupEval

- rqRowEval

- rqTableEval

表6-1に、Rインタフェース関数およびそれに相当するSQL関数を示します。

rqGroupEval関数の場合、Oracle R EnterpriseはSQLでのグループ適用機能の汎用実装を提供します。入力カーソルの後続を取得する表関数を記述する必要があります。

次の各トピックでは、SQL表関数の一般的な側面について説明します。

- 「SQL表関数のパラメータ」

- 「SQL表関数の戻り値」

- 「埋込みRの実行でのOracle R Enterpriseへの接続」

これらの関数の詳細および使用例は、各関数の参照ページを参照してください。

関連項目:

rqEval関数

rqGroupEval関数

rqRowEval関数

rqTableEval関数

6.3.1.1 SQL表関数のパラメータ

SQL表関数の中には、共通のパラメータを持つものもあれば、その関数に固有のパラメータを持つものもあります。SQL表関数のパラメータは次のとおりです。

表6-2 SQL表関数のパラメータ

パラメータ

説明

INP_CUR

EXP_NAMで指定されているR関数への入力となるデータを指定するカーソル。rqEvalを除くすべてのSQL表関数の最初の引数は、R関数の入力データを指定するカーソルです。

PAR_CUR

R関数に渡す引数を指定するカーソル。パラメータ・カーソルは、単一行のスカラー値で構成されます。引数には文字列または数値を指定できます。カーソル内には複数の引数を指定できます。R関数への引数では大/小文字が区別されるため、列名などの名前は二重引用符で囲む必要があります。

カーソル内には、Oracle R Enterprise制御引数やシリアライズされたRオブジェクト(Oracle R Enterpriseデータストア内にある予測モデルなど)の名前をスカラー値として指定することもできます。

R関数への引数も制御引数も渡さない場合は、このパラメータ・カーソルの値をNULLにできます。

OUT_QRY

出力表の定義。この引数の値は、NULLか、EXP_NAMで指定されているR関数により返されたR data.frameの構造を定義する文字列にすることができます。文字列は、SELECT文、'XML'または'PNG'にできます。

GRP_COL

rqGroupEval関数の場合、グループ化列の名前。

ROW_NUM

rqRowEval関数の場合、R関数の各呼出しに渡す行数。

EXP_NAM

Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前。

関連項目:

SQLでのスクリプトの管理

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

6.3.1.2 SQL表関数の戻り値

Oracle R EnterpriseのSQL表関数は、表を返します。表の構造と内容は、SQL表関数に渡されたR関数の結果と、OUT_QRYパラメータによって決定されます。R関数はdata.frameオブジェクト、他のRオブジェクトおよびグラフィックを返すことができます。R関数の結果を表す表の構造は、次のいずれかのOUT_QRY値によって指定されます。

- NULL: データ・オブジェクトとイメージ・オブジェクトの両方を含む可能性のあるシリアライズ・オブジェクトを持つ表が返されます。

- SELECT文で指定された表シグネチャ: 定義された構造の表が返されます。R関数の結果はdata.frameとなる必要があります。イメージは返されません。

- 文字列'XML': XML文字列での構造化データとグラフ・イメージの両方を含む可能性のあるCLOBを持つ表が返されます。イメージでないRオブジェクト(data.frameやmodelオブジェクトなど)が最初に提供され、次にbase 64でエンコードされたイメージのPNG表示が続きます。

- 文字列'PNG': PNG形式のグラフ・イメージを含むBLOBを持つ表が返されます。表には、列名name、idおよびimageが含まれます。

6.3.1.3 埋込みRの実行でのOracle R Enterpriseへの接続

埋込みRの実行中にOracle Databaseサーバー上のOracle R Enterpriseへの接続を確立するには、パラメータ・カーソル内に制御引数ore.connectを指定できます。これを行うと、埋込みR関数を呼び出したユーザーの資格証明を使用して接続が確立されます。また、自動的にOREパッケージがロードされます。オブジェクトをOracle R EnterpriseのRオブジェクト・データストアに保存する場合や、データソースからオブジェクトをロードする場合は、Oracle R Enterpriseへの接続を確立する必要があります。また、これにより、Oracle R Enterpriseの透過層を明示的に使用できます。

関連項目:

他の制御引数の詳細は、「オプションの制御引数」を参照してください。

6.3.2 SQLでのスクリプトの管理

このトピックでは、Rスクリプトを作成および管理するためのPL/SQLプロシージャとOracle Databaseデータ・ディクショナリ・ビューを紹介します。

埋込みRの実行用のSQL APIの関数は、Oracle R EnterpriseのRスクリプト・リポジトリに格納されている名前付きのスクリプトを引数として必要とします。PL/SQLプロシージャsys.rqScriptCreateおよびsys.rqScriptDropは、スクリプトを作成および削除します。スクリプトを作成する場合やOracle R EnterpriseのRスクリプト・リポジトリから削除する場合は、RQADMINロールが必要です。

sys.rqScriptCreate関数を使用する場合、スクリプトの名前と、1つのR関数定義を含むR関数スクリプトを指定する必要があります。関数sys.rqScriptCreateおよびsys.rqScriptDropのコールは、BEGIN-END PL/SQLブロックでラップする必要があります。Rスクリプト・リポジトリには、R関数がキャラクタ・ラージ・オブジェクト(CLOB)として格納されるため、関数定義を一重引用符で囲んで文字列として指定する必要があります。

スクリプトの所有者は、rqGrantプロシージャを使用してスクリプトへの読取りアクセス権を別のユーザーに付与したり、rqRevokeプロシージャを使用して権限を取り消すことができます。別のユーザーによってアクセス権を付与されたスクリプトを使用するには、次のように、スクリプトの名前の前に所有者の名前とピリオドを付加して、所有者を指定する必要があります。

select * from table(rqEval(NULL, 'select 1 x from dual', 'owner_name.script_name'));

パブリック・スクリプトやユーザーが所有しているスクリプトには、所有者の接頭辞は必要ありません。

次の各表は、Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトを管理するためのPL/SQLプロシージャと、スクリプトに関する情報を格納するデータ・ディクショナリ・ビューのリストです。

表6-3 スクリプトを管理するためのPL/SQLプロシージャ

PL/SQLプロシージャ

説明

rqGrant

データストアまたはスクリプトへの読取りアクセス権を付与します。

rqRevoke

データストアまたはスクリプトへの読取りアクセス権を取り消します。

sys.rqScriptCreate

指定されたR関数を、指定された名前でOracle R EnterpriseのRスクリプト・リポジトリに追加します。

sys.rqScriptDrop

指定されたR関数をOracle R EnterpriseのRスクリプト・リポジトリから削除します。

表6-4 スクリプトのデータ・ディクショナリ・ビュー

データ・ディクショナリ・ビュー

説明

ALL_RQ_SCRIPTS

現行のユーザーが使用可能な、Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトを示します。

USER_RQ_SCRIPTS

現行のユーザーが所有している、Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトを示します。

USER_RQ_SCRIPT_PRIVS

現行のユーザーが読取りアクセス権を付与したOracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトおよびアクセス権が付与されたユーザーを示します。

SYS.RQ_SCRIPTS

Oracle R EnterpriseのRスクリプト・リポジトリ内のシステム・スクリプトを示します。

関連項目:

SQL APIによるスクリプトの作成

Oracle R EnterpriseのSQL API

Oracle R EnterpriseのOracle Databaseビュー

Rでのスクリプトの管理

6.3.2.1 SQL APIによるスクリプトの作成

この例では、sys.rqScriptCreateプロシージャを使用して、Oracle R EnterpriseのRスクリプト・リポジトリ内にスクリプトを作成します。

この例では、myRandomRedDots2という名前のユーザー定義関数を作成します。このユーザー定義関数は2つの引数を受け入れ、2つの列を持ち指定の数のランダム標準値を表示するdata.frameオブジェクトを返します。sys.rqScriptCreate関数は、ユーザー定義関数をOracle R Enterpriseのスクリプト・リポジトリに格納します。

-- Create a script named myRandomRedDots2 and add it to the R script repository.
-- Specify that the script is private and to overwrite a script with the same name.
BEGIN
sys.rqScriptCreate('myRandomRedDots2',
'function(divisor = 100, numDots = 100) {
id <- 1:10
plot(1:numDots, rnorm(numDots), pch = 21, bg = "red", cex = 2 )
data.frame(id = id, val = id / divisor)}',
v_global => FALSE,
v_overwrite => TRUE);
END;
/

-- Grant read privilege access to Scott.
BEGIN
rqGrant('myRandomRedDots2', 'rqscript', 'SCOTT');
END;
/

-- View the users granted read access to myRandomRedDots2.
select * from USER_RQ_SCRIPT_PRIVS;

NAME                GRANTEE
----------------    -------
myRandomRedDots       SCOTT

-- Revoke the read privilege access from Scott.
BEGIN
rqRevoke('myRandomRedDots2', 'rqscript', 'SCOTT');
END;
/

-- Remove the script from the R script repository.
BEGIN
sys.rqScriptDrop('myRandomRedDots2');
END;
/

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

Oracle R Enterpriseには、SQLでデータストアの基本的な管理を行うためのPL/SQLプロシージャおよびOracle Databaseデータ・ディクショナリ・ビューが用意されています。次の各表は、これらのプロシージャおよびビューのリストです。

表6-5 データストアを管理するためのPL/SQLプロシージャ

PL/SQLプロシージャ

説明

rqGrant

データストアまたはスクリプトへの読取りアクセス権を付与します。

rqRevoke

データストアまたはスクリプトへの読取りアクセス権を取り消します。

rqDropDataStore

データストアを削除します。

表6-6 データストアのデータ・ディクショナリ・ビュー

ビュー

説明

ALL_RQ_DATASTORES

データストアが付与可能かどうかを含め、現行のユーザーが使用可能なデータストアを示します。

RQUSER_DATASTORELIST

Oracle Databaseスキーマ内のデータストアを示します。

RQUSER_DATASTORECONTENTS

Oracle Databaseスキーマ内のデータストア内のオブジェクトを示します。

USER_RQ_DATASTORE_PRIVS

データストア、および現行のユーザーが読取りアクセス権を付与したユーザーを示します。

USER_RQ_DATASTORES

データストアが付与可能かどうかを含め、現行のユーザーが所有しているデータストアを示します。

関連項目:

Oracle R EnterpriseのSQL API

Oracle R EnterpriseのOracle Databaseビュー

A Oracle R EnterpriseのSQL API

Oracle R EnterpriseのSQL APIには、Oracle R Enterprise Serverデータベース上の1つ以上の埋込みRセッションでR関数を実行するためのSQL表関数と、Oracle R Enterpriseのデータストアを管理したり、Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトを管理するためのPL/SQLプロシージャが含まれます。

Oracle R EnterpriseのSQL APIについては、次の各トピックで説明します。

埋込みRの実行用のSQL表関数

- rqEval関数

- rqGroupEval関数

- rqRowEval関数

- rqTableEval関数

データストアおよびスクリプトを管理するためのPL/SQLプロシージャ

- rqDropDataStoreプロシージャ

- rqGrantプロシージャ

- rqRevokeプロシージャ

- sys.rqScriptCreateプロシージャ

- sys.rqScriptDropプロシージャ

A.1 rqDropDataStoreプロシージャ

rqDropDataStoreプロシージャは、Oracle Databaseスキーマからデータストアを削除します。

構文

rqDropDataStore (
DS_NAME     VARCHAR2     IN)

パラメータ

パラメータ

説明

DS_NAME

削除するデータストアの名前。

例A-1 データストアの削除

この例では、現行ユーザー・スキーマからデータストアdatastore_1を削除します。

rqDropDataStore('datastore_1')

関連項目:

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

Oracle R EnterpriseのOracle Databaseビュー

USER_RQ_DATASTORES

USER_RQ_DATASTORE_PRIVS

A.2 rqEval関数

rqEval関数は、EXP_NAMパラメータで指定されているスクリプト内のR関数を実行します。PAR_CURパラメータを使用して、引数をR関数に渡すことができます。

rqEval関数は、データベースからのデータを自動的には受信しません。R関数は、使用するデータを生成するか、Oracle Database、他のデータベース、フラット・ファイルなどのデータソースからデータを明示的に取得します。

R関数は、データベース内にSQL表として表示されるR data.frameオブジェクトを返します。OUT_QRYパラメータを使用して、返される値の形式を定義します。

構文

rqEval (
PAR_CUR     REF CURSOR     IN
OUT_QRY     VARCHAR2       IN)
EXP_NAM     VARCHAR2       IN)

パラメータ

パラメータ

説明

PAR_CUR

EXP_NAMEパラメータで指定されているR関数に渡す引数値を含むカーソル。

OUT_QRY

次のうちの1つ。

- NULL。データ・オブジェクトとイメージ・オブジェクトの両方を含む可能性のあるシリアライズ・オブジェクトを返します。

- rqEvalにより返された表の列名およびデータ型を指定するSQL SELECT文。イメージ・データは破棄されます。デュアル・ダミー表を使用してプロトタイプ行を指定することも、既存の表またはビューに基づいてSELECT文を作成することもできます。R関数はdata.frameを返す必要があります。

- 文字列'XML'。返される表にXML文字列であるCLOBが含まれることを指定します。XMLには構造化データとイメージの両方が含まれる可能性があり、最初に構造化Rオブジェクトまたは半構造化Rオブジェクトが返され、次にR関数により生成されたイメージが続きます。イメージはPNG表示のbase 64エンコーディングとして返されます。

- 文字列'PNG'。返される表に、R関数により生成されたPNG形式のイメージを持つBLOBが含まれることを指定します。

EXP_NAM

Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前。

戻り値

関数rqEvalは、OUT_QRYパラメータ値で指定されている構造を持つ表を返します。

例

例A-2 rqEvalの使用方法

この例では、スクリプトmyRandomRedDots2を作成します。rqEvalの最初のパラメータの値は、関数myRandomRedDots2に引数を渡さないことを指定するNULLです。2番目のパラメータの値は、rqEvalにより返されたdata.frameの列名およびデータ型を記述するSQL文を指定する文字列です。3番目のパラメータの値は、Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前です。

-- Create a script named myRandomRedDots2 and add it to the R script repository.
-- Specify that the script is private and to overwrite a script with the same name.
BEGIN
sys.rqScriptCreate('myRandomRedDots2',
'function(divisor = 100, numDots = 100) {
id <- 1:10
plot(1:numDots, rnorm(numDots), pch = 21, bg = "red", cex = 2 )
data.frame(id = id, val = id / divisor)}',
v_global => FALSE,
v_overwrite => TRUE);
END;
/

SELECT *
FROM table(rqEval(NULL, 'SELECT 1 id, 1 val FROM dual', 'myRandomRedDots2'));

Oracle SQL DeveloperでのSELECT文の結果は次のようになります。

ID        VAL
---------- ----------
1        .01
2        .02
3        .03
4        .04
5        .05
6        .06
7        .07
8        .08
9        .09
10         .1

10 rows selected

例A-3 rqEvalにより呼び出されたR関数に引数を渡す

この例では、rqEvalの最初のパラメータとしてカーソルを指定することにより、R関数に引数を渡します。カーソルは、単一行のスカラー値の中に複数の引数を指定します。

SELECT *
FROM table(rqEval(cursor(SELECT 50 "divisor", 500 "numDots" FROM dual),
'SELECT 1 id, 1 val FROM dual',
'myRandomRedDots2'));

Oracle SQL DeveloperでのSELECT文の結果は次のようになります。

ID        VAL
---------- ----------
1        .02
2        .04
3        .06
4        .08
5         .1
6        .12
7        .14
8        .16
9        .18
10         .2

10 rows selected

例A-4 出力表定義としてのPNGの指定

この例では、PNG_Exampleというスクリプトを作成し、Oracle R EnterpriseのRスクリプト・リポジトリに格納します。rqEvalを呼び出すと、'PNG'のOUT_QRY値が指定されます。

BEGIN
sys.rqScriptDrop('PNG_Example');
sys.rqScriptCreate('PNG_Example',
'function(){
dat <- data.frame(y = log(1:100), x = 1:100)
plot(lm(y ~ x, dat))
}');
END;
/
SELECT *
FROM table(rqEval(NULL,'PNG','PNG_Example'));

Oracle SQL DeveloperでのSELECT文の結果は次のようになります。

NAME     ID  IMAGE
------ ----  ------
1  (BLOB)
2  (BLOB)
3  (BLOB)
4  (BLOB)

A.3 rqGrantプロシージャ

rqGrantプロシージャは、Oracle R EnterpriseのデータストアまたはOracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトへの読取りアクセス権を付与します。

構文

rqGrant (
V_NAME     VARCHAR2     IN
V_TYPE     VARCHAR2     IN
V_USER     VARCHAR2     IN     DEFAULT)

パラメータ

パラメータ

説明

V_NAME

Oracle R EnterpriseのデータストアまたはOracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前。

V_TYPE

データストアの場合、タイプはdatastoreです。スクリプトの場合、タイプはrqscriptです。

V_USER

アクセス権を付与するユーザーの名前。

例A-5 スクリプトへの読取りアクセス権の付与

-- Grant read privilege access to Scott.
BEGIN
rqGrant('myRandomRedDots2', 'rqscript', 'SCOTT');
END;
/

関連項目:

rqRevokeプロシージャ

A.4 rqGroupEval関数

rqGroupEval関数は、グループ化列を識別するユーザー定義関数です。ユーザーは、SQLでのグループ適用機能の汎用実装であるSQLオブジェクトrqGroupEvalImplを使用して、PL/SQLでrqGroupEval関数を定義します。この実装ではデータ・パラレル実行がサポートされており、1つ以上のRエンジンにより同じR関数(タスク)が異なるデータ・パーティションで実行されます。データは、グループ化列の値に従ってパーティショニングされます。

1つのグループ化列のみがサポートされています。複数の列がある場合、それらの列を1つの列に結合して、その新しい列をグループ化列として使用します。

rqGroupEval関数は、EXP_NAMパラメータで指定されたスクリプト内のR関数を実行します。INP_CURパラメータを使用して、データをR関数に渡します。PAR_CURパラメータを使用して、引数をR関数に渡すことができます。

R関数は、データベース内にSQL表として表示されるR data.frameオブジェクトを返します。OUT_QRYパラメータを使用して、返される値の形式を定義します。

rqGroupEval関数を作成するには、次の2つのPL/SQLオブジェクトを作成します。

- 返される結果の型を指定するPL/SQLパッケージ。

- パッケージの戻り値を取り、その戻り値とPIPELINED_PARALLEL_ENABLEセットを使用してデータをパーティショニングする列を示す関数。

構文

rqGroupEval (
INP_CUR     REF CURSOR     IN
PAR_CUR     REF CURSOR     IN
OUT_QRY     VARCHAR2       IN
GRP_COL     VARCHAR2       IN
EXP_NAM     VARCHAR2       IN)

パラメータ

パラメータ

説明

INP_CUR

EXP_NAMEパラメータで指定されているR関数に渡すデータを指定するカーソル。

PAR_CUR

R関数に渡す引数値を含むカーソル。

OUT_QRY

次のうちの1つ。

- NULL。データ・オブジェクトとイメージ・オブジェクトの両方を含む可能性のあるシリアライズ・オブジェクトを返します。

- rqEvalにより返された表の列名およびデータ型を指定するSQL SELECT文。イメージ・データは破棄されます。デュアル・ダミー表を使用してプロトタイプ行を指定することも、既存の表またはビューに基づいてSELECT文を作成することもできます。R関数はdata.frameを返す必要があります。

- 文字列'XML'。返される表にXML文字列であるCLOBが含まれることを指定します。XMLには構造化データとイメージの両方が含まれる可能性があり、最初に構造化Rオブジェクトまたは半構造化Rオブジェクトが返され、次にR関数により生成されたイメージが続きます。イメージはPNG表示のbase 64エンコーディングとして返されます。

- 文字列'PNG'。返される表に、R関数により生成されたPNG形式のイメージを持つBLOBが含まれることを指定します。

GRP_COL

データのパーティショニングに使用するグループ化列の名前。

EXP_NAM

Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前。

戻り値

ユーザー定義のrqGroupEval関数は、OUT_QRYパラメータ値で指定された構造を持つ表を返します。

例

例A-6のPL/SQLブロックでは、スクリプトmyC5.0FunctionがOracle R EnterpriseのRスクリプト・リポジトリ内に存在しないようにするために、このスクリプトを削除します。その後、関数を作成し、それをスクリプトmyC5.0FunctionとしてRスクリプト・リポジトリに格納します。

このR関数は、2つの引数(操作対象のデータと、データストアの作成で使用する接頭辞)を受け入れます。この関数はC50パッケージを使用して、C50からのchurnデータセットに基づいてC5.0モデルを構築します。この関数は、状態ごとのデータに基づいて1つのチャーン・モデルを構築します。

myC5.0Function関数はC50パッケージをロードして、データベース・サーバーのRエンジンで関数が実行されるときにその関数本体がC50パッケージにアクセスできるようにします。次に、データストアの接頭辞および状態の名前を使用して、データストア名を作成します。モデルから状態名を除外するために、この関数はdata.frameから列を削除します。data.frame内のファクタはユーザー定義の埋込みR関数にロードされるときに文字列ベクターに変換されるため、myC5.0Function関数は明示的に文字ベクターをRファクタに戻します。

myC5.0Function関数は、指定された列から状態のデータを取得し、その状態のモデルを作成して、モデルをデータストアに保存します。R関数は、関数の実行結果として表示可能な単純な値を持つためにTRUEを返します。

例A-6では次に、PL/SQLパッケージchurnPkgおよびユーザー定義関数churnGroupEvalを作成します。rqGroupEval関数実装を定義する際、PARALLEL_ENABLE句はオプションですが、CLUSTER BY句は必須です。

最後に、churnGroupEval関数を呼び出すSELECT文を実行します。churnGroupEval関数のINP_CUR引数で、SELECT文は、R関数およびR関数に渡すデータセットのパラレル実行を使用するようにPARALLELヒントを指定します。churnGroupEval関数のINP_CUR引数は、Oracle R Enterpriseへの接続およびR関数に渡すデータストア接頭辞を指定します。OUT_QRY引数はXML形式の値を返すことを指定し、GRP_NAM引数は、グループ化列としてデータセットの状態列を使用することを指定し、EXP_NAM引数は、呼び出すR関数としてRスクリプト・リポジトリ内のmyC5.0Functionスクリプトを指定します。

50州とワシントンD.Cのそれぞれについて、SELECT文は、churnGroupEval表関数から州の名前と値TRUEを含むXML文字列を返します。

関連項目:

例6-13

例A-6 rqGroupEval関数の使用方法

BEGIN
sys.rqScriptDrop('myC5.0Function');
sys.rqScriptCreate('myC5.0Function',
'function(dat, datastorePrefix) {
library(C50)
datastoreName <- paste(datastorePrefix, dat[1, "state"], sep = "_")
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)
mod <- C5.0(churn ~ ., data = dat, rules = TRUE)
ore.save(mod, name = datastoreName)
TRUE
}');
END;
/

CREATE OR REPLACE PACKAGE churnPkg AS
TYPE cur IS REF CURSOR RETURN CHURN_TRAIN%ROWTYPE;
END churnPkg;
/
CREATE OR REPLACE FUNCTION churnGroupEval(
inp_cur churnPkg.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 ("state"))
CLUSTER inp_cur BY ("state")
USING rqGroupEvalImpl;
/

SELECT *
FROM table(churnGroupEval(
cursor(SELECT * /*+ parallel(t,4) */ FROM CHURN_TRAIN t),
cursor(SELECT 1 AS "ore.connect",
'myC5.0model' AS "datastorePrefix" FROM dual),
'XML', 'state', 'myC5.0Function'));

A.5 rqRevokeプロシージャ

rqRevokeプロシージャは、Oracle R EnterpriseのデータストアまたはOracle DatabaseのRスクリプト・リポジトリ内のスクリプトへの読取りアクセス権を取り消します。

構文

rqGrant (
V_NAME     VARCHAR2     IN
V_TYPE     VARCHAR2     IN
V_USER     VARCHAR2     IN     DEFAULT)

パラメータ

パラメータ

説明

V_NAME

Oracle R EnterpriseのデータストアまたはOracle DatabaseのRスクリプト・リポジトリ内のスクリプトの名前。

V_TYPE

データストアの場合、タイプはdatastoreです。スクリプトの場合、タイプはrqscriptです。

V_USER

アクセス権を取り消すユーザーの名前。

例A-7 スクリプトへの読取りアクセス権の取消し

-- Revoke read privilege access to Scott.
BEGIN
rqRevoke('myRandomRedDots2', 'rqscript', 'SCOTT');
END;
/

関連項目:

rqGrantプロシージャ

A.6 rqRowEval関数

rqRowEval関数は、EXP_NAMパラメータで指定されているスクリプト内のR関数を実行します。INP_CURパラメータを使用して、データをR関数に渡します。PAR_CURパラメータを使用して、引数をR関数に渡すことができます。ROW_NUMパラメータは、R関数の各呼出しに渡す必要のある行数を指定します。最後のチャンクの行数は、指定した数より少なくなる可能性があります。

rqRowEval関数ではデータ・パラレル実行がサポートされており、1つ以上のRエンジンにより同じR関数(タスク)が個々の独立したデータ・チャンクで実行されます。Oracle Databaseは、データベース・サーバー・マシンで実行されるRエンジン(複数の場合もある)の管理および制御を処理し、自動的にデータをチャンク化して、パラレルで実行されるRエンジンに渡します。Oracle Databaseでは行のすべてのチャンクに対するR関数の実行完了が保証されており、完了しない場合はrqRowEval関数によってエラーが返されます。

R関数は、データベース内にSQL表として表示されるR data.frameオブジェクトを返します。OUT_QRYパラメータを使用して、返される値の形式を定義します。

構文

rqRowEval (
INP_CUR     REF CURSOR     IN
PAR_CUR     REF CURSOR     IN
OUT_QRY     VARCHAR2       IN
ROW_NUM     NUMBER         IN
EXP_NAM     VARCHAR2       IN)

パラメータ

表A-1 rqRowEval関数のパラメータ

パラメータ

説明

INP_CUR

EXP_NAMEパラメータで指定されているR関数に渡すデータを指定するカーソル。

PAR_CUR

R関数に渡す引数値を含むカーソル。

OUT_QRY

次のうちの1つ。

- NULL。データ・オブジェクトとイメージ・オブジェクトの両方を含む可能性のあるシリアライズ・オブジェクトを返します。

- rqEvalにより返された表の列名およびデータ型を指定するSQL SELECT文。イメージ・データは破棄されます。デュアル・ダミー表を使用してプロトタイプ行を指定することも、既存の表またはビューに基づいてSELECT文を作成することもできます。R関数はdata.frameを返す必要があります。

- 文字列'XML'。返される表にXML文字列であるCLOBが含まれることを指定します。XMLには構造化データとイメージの両方が含まれる可能性があり、最初に構造化Rオブジェクトまたは半構造化Rオブジェクトが返され、次にR関数により生成されたイメージが続きます。イメージはPNG表示のbase 64エンコーディングとして返されます。

- 文字列'PNG'。返される表に、R関数により生成されたPNG形式のイメージを持つBLOBが含まれることを指定します。

ROW_NUM

R関数の各呼出しに含める行数。

EXP_NAM

Oracle DatabaseのRスクリプト・リポジトリ内のスクリプトの名前。

戻り値

関数rqRowEvalは、OUT_QRYパラメータ値で指定されている構造を持つ表を返します。

例

例A-8では、C50パッケージを使用し、C5.0ディシジョン・ツリー・モデルを使用してチャーン・データをスコアリングします(つまり、解約傾向が高い顧客を予測します)。この例では、指定された状態からの顧客を並行してスコアリングします。この例では、例6-16の関数ore.rowApplyを呼び出した場合と同じ結果になります。

ヒント:

例A-8では、例6-16で作成したCHURN_TEST表およびmyXLevelsデータストアを使用するため、例A-8を実行する前に、例6-16で表を作成する関数、xlevelsオブジェクトを取得する関数、およびそれをmyXLevelsデータストアに保存する関数をRで呼び出す必要があります。

例A-8では、例A-6と同様にユーザー定義関数を作成し、その関数をOracle DatabaseのRスクリプト・リポジトリに保存します。このユーザー定義関数は状態のC5.0モデルを作成し、そのモデルをデータストアに保存します。ただし、例A-8のユーザー定義関数myC5.0FunctionForLevelsは、例A-6の関数myC5.0Functionのようにas.factor関数を使用してレベルを計算するのではなく、例6-16で作成されたレベルのリストを使用します。関数myC5.0FunctionForLevelsは、値TRUEを返します。

例A-8では、例A-6と同様にPL/SQLパッケージchurnPkgおよび関数churnGroupEvalを作成します。例A-6では、文字列myC5.0modelFLを含むデータストアの名前を取得するためのカーソルを宣言した後、それらのデータストアを削除するPL/SQLブロックを実行します。次に、churnGroupEval関数を呼び出すSELECT文を実行します。churnGroupEval関数はmyC5.0FunctionForLevels関数を呼び出してC5.0モデルを生成し、それをデータストアに保存します。

例A-8では次に、myScoringFunction関数を作成し、それをRスクリプト・リポジトリに保存します。この関数は、状態のレベルでC5.0モデルをスコアリングし、結果をdata.frameで返します。

例A-8では最後に、rqRowEval関数を呼び出すSELECT文を実行します。rqRowEval関数への入力カーソルはPARALLELヒントを使用して、使用する並列度レベルを指定します。カーソルはデータソースとしてCHURN_TEST表を指定し、マサチューセッツの行のみが含まれるように行をフィルタ処理します。処理される行はすべて同じ予測モデルを使用します。

パラメータ・カーソルはore.connect制御引数を指定して、データベース・サーバー上のOracle R Enterpriseに接続し、myScoringFunction関数へのdatastorePrefix引数とxlevelsDatastore引数の値を指定します。

OUT_QRYパラメータのSELECT文は、出力形式を指定します。ROW_NUMパラメータでは、各パラレルRエンジンで一度に処理する行数として200を指定します。EXP_NAMEパラメータでは、呼び出すR関数としてRスクリプト・リポジトリ内のmyScoringFunctionを指定します。

例A-8 rqRowEval関数の使用方法

BEGIN
sys.rqScriptDrop('myC5.0FunctionForLevels');
sys.rqScriptCreate('myC5.0FunctionForLevels',
'function(dat, xlevelsDatastore, datastorePrefix) {
library(C50)
state <- dat[1,"state"]
datastoreName <- paste(datastorePrefix, dat[1, "state"], sep = "_")
dat$state <- NULL
ore.load(name = xlevelsDatastore) # To get the xlevels object.
for (j in names(xlevels))
dat[[j]] <- factor(dat[[j]], levels = xlevels[[j]])
c5mod <- C5.0(churn ~ ., data = dat, rules = TRUE)
ore.save(c5mod, name = datastoreName)
TRUE
}');
END;
/

CREATE OR REPLACE PACKAGE churnPkg AS
TYPE cur IS REF CURSOR RETURN CHURN_TEST%ROWTYPE;
END churnPkg;
/
CREATE OR REPLACE FUNCTION churnGroupEval(
inp_cur churnPkg.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 ("state"))
CLUSTER inp_cur BY ("state")
USING rqGroupEvalImpl;
/

DECLARE
CURSOR c1
IS
SELECT dsname FROM rquser_DataStoreList WHERE dsname like 'myC5.0modelFL%';

BEGIN
FOR dsname_st IN c1
LOOP
rqDropDataStore(dsname_st.dsname);
END LOOP;
END;

SELECT *
FROM table(churnGroupEval(
cursor(SELECT * /*+ parallel(t,4) */ FROM CHURN_TEST t),
cursor(SELECT 1 AS "ore.connect",
'myXLevels' as "xlevelsDatastore",
'myC5.0modelFL' AS "datastorePrefix" FROM dual),
'XML', 'state', 'myC5.0FunctionForLevels'));

BEGIN
sys.rqScriptDrop('myScoringFunction');
sys.rqScriptCreate('myScoringFunction',
'function(dat, xlevelsDatastore, datastorePrefix) {
library(C50)
state <- dat[1, "state"]
datastoreName <- paste(datastorePrefix, state, sep = "_")
dat$state <- NULL
ore.load(name = xlevelsDatastore) # To get the xlevels object.
for (j in names(xlevels))
dat[[j]] <- factor(dat[[j]], levels = xlevels[[j]])
ore.load(name = datastoreName)
res <- data.frame(pred = predict(c5mod, dat, type = "class"),
actual= dat$churn,
state = state)
res
}');
END;
/

SELECT * FROM table(rqRowEval(
cursor(select /*+ parallel(t, 4) */ *
FROM CHURN_TEST t
WHERE "state" = 'MA'),
cursor(SELECT 1 as "ore.connect",
'myC5.0modelFL' as "datastorePrefix",
'myXLevels' as "xlevelsDatastore"
FROM dual),
'SELECT ''aaa'' "pred",''aaa'' "actual" , ''aa'' "state" FROM dual',
200, 'myScoringFunction'));

Oracle SQL Developerでの最後のSELECT文の結果は次のようになります。

pred actual state
---- ------ -----
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   yes    MA
yes  yes    MA
yes  yes    MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
yes  yes    MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   no     MA
no   yes    MA
no   no     MA
no   no     MA
no   no     MA
yes  yes    MA
no   no     MA
no   no     MA
no   no     MA

38 rows selected

A.7 rqTableEval関数

rqTableEval関数は、EXP_NAMパラメータで指定されているスクリプト内のR関数を実行します。INP_CURパラメータを使用して、データをR関数に渡します。PAR_CURパラメータを使用して、引数をR関数に渡すことができます。

R関数は、データベース内にSQL表として表示されるR data.frameオブジェクトを返します。OUT_QRYパラメータを使用して、返される値の形式を定義します。

構文

rqTableEval (
INP_CUR     REF CURSOR     IN
PAR_CUR     REF CURSOR     IN
OUT_QRY     VARCHAR2       IN
EXP_NAM     VARCHAR2       IN)

パラメータ

表A-2 rqTableEval関数のパラメータ

パラメータ

説明

INP_CUR

EXP_NAMEパラメータで指定されているR関数に渡すデータを指定するカーソル。

PAR_CUR

入力関数に渡す引数値を含むカーソル。

OUT_QRY

次のうちの1つ。

- NULL。データ・オブジェクトとイメージ・オブジェクトの両方を含む可能性のあるシリアライズ・オブジェクトを返します。

- rqEvalにより返された表の列名およびデータ型を指定するSQL SELECT文。イメージ・データは破棄されます。デュアル・ダミー表を使用してプロトタイプ行を指定することも、既存の表またはビューに基づいてSELECT文を作成することもできます。R関数はdata.frameを返す必要があります。

- 文字列'XML'。返される表にXML文字列であるCLOBが含まれることを指定します。XMLには構造化データとイメージの両方が含まれる可能性があり、最初に構造化Rオブジェクトまたは半構造化Rオブジェクトが返され、次にR関数により生成されたイメージが続きます。イメージはPNG表示のbase 64エンコーディングとして返されます。

- 文字列'PNG'。返される表に、R関数により生成されたPNG形式のイメージを持つBLOBが含まれることを指定します。

EXP_NAM

Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前。

戻り値

関数rqTableEvalは、OUT_QRYパラメータ値で指定されている構造を持つ表を返します。

例

例A-9の最初にあるPL/SQLブロックでは、スクリプトmyNaiveBayesModelがOracle R EnterpriseのRスクリプト・リポジトリ内に存在しないようにするために、このスクリプトを削除します。次に、関数を作成して、それをスクリプトmyNaiveBayesModelとしてリポジトリに格納します。

このR関数は、2つの引数(操作対象のデータおよびデータストアの名前)を受け入れます。この関数は、irisデータセットに基づいてNaive Bayesモデルを構築します。Naive Bayesはe1071パッケージ内にあります。

myNaiveBayesModel関数はe1071パッケージをロードして、データベース・サーバーのRエンジンで関数が実行されるときにその関数本体がe1071パッケージにアクセスできるようにします。data.frame内のファクタはユーザー定義の埋込みR関数にロードされるときに文字列ベクターに変換されるため、myNaiveBayesModel関数は明示的に文字ベクターをRファクタに変換します。

myNaiveBayesModel関数は指定された列からデータを取得した後、モデルを作成してデータストアに保存します。R関数は、関数の実行結果として表示可能な単純な値を持つためにTRUEを返します。

例A-9では次に、rqTableEval関数を呼び出すSELECT文を実行します。churnGroupEval関数のINP_CUR 引数で、SELECT文は、R関数に渡すデータセットを指定します。データは、ore.create(iris, "IRIS")の呼出しによって作成されたIRIS表から取得されます(この例には示していません)。rqTableEval関数のINP_CUR引数は、R関数に渡すデータストアの名前を指定し、ユーザー定義のR関数の埋込みRの実行中にデータベースへのOracle R Enterprise接続を確立するためのore.connect制御引数を指定します。OUT_QRY引数はXML形式の値を返すことを指定し、EXP_NAM引数は、呼び出すR関数としてRスクリプト・リポジトリ内のmyNaiveBayesModelスクリプトを指定します。

例A-9 rqTableEval関数の使用方法

BEGIN
sys.rqScriptDrop('myNaiveBayesModel');
sys.rqScriptCreate('myNaiveBayesModel',
'function(dat, datastoreName) {
library(e1071)
dat$Species <- as.factor(dat$Species)
nbmod <- naiveBayes(Species ~ ., dat)
ore.save(nbmod, name = datastoreName)
TRUE
}');
END;
/

SELECT *
FROM table(rqTableEval(
cursor(SELECT * FROM IRIS),
cursor(SELECT 'myNaiveBayesDatastore' "datastoreName",
1 as "ore.connect" FROM dual),
'XML', 'myNaiveBayesModel'));

SELECT文は、rqTableEval表関数から値TRUEを含むXML文字列を返します。

次のSELECT文に示すとおり、myNaiveBayesDatastoreデータソースが生成され、オブジェクトnbmodがこのデータソースに存在しています。

SQL> SELECT * from rquser_DataStoreContents
2     WHERE dsname = 'myNaiveBayesDatastore';

DSNAME                  OBJNAME  CLASS       OBJSIZE  LENGTH  NROW  NCOL
---------------------   -------  ----------  -------  ------  ----  ----
myNaiveBayesDatastore   nbmod    naiveBayes     1485       4

次のように、ローカルのRセッションでモデルをロードして表示できます。

R> ore.load("myNaiveBayesDatastore")
[1] "nbmod"
R> nbmod
$apriori
Y
setosa versicolor  virginica
50         50         50

$tables
$tables$Sepal.Length
Sepal.Length
Y             [,1]      [,2]
setosa     5.006 0.3524897
versicolor 5.936 0.5161711
virginica  6.588 0.6358796

$tables$Sepal.Width
Sepal.Width
Y             [,1]      [,2]
setosa     3.428 0.3790644
versicolor 2.770 0.3137983
virginica  2.974 0.3224966

$tables$Petal.Length
Petal.Length
Y             [,1]      [,2]
setosa     1.462 0.1736640
versicolor 4.260 0.4699110
virginica  5.552 0.5518947

$tables$Petal.Width
Petal.Width
Y             [,1]      [,2]
setosa     0.246 0.1053856
versicolor 1.326 0.1977527
virginica  2.026 0.2746501

$levels
[1] "setosa"     "versicolor" "virginica"

$call
naiveBayes.default(x = X, y = Y, laplace = laplace)

attr(,"class")
[1] "naiveBayes"

A.8 sys.rqScriptCreateプロシージャ

sys.rqScriptCreateプロシージャは、スクリプトを作成し、それをOracle R EnterpriseのRスクリプト・リポジトリに追加します。

構文

sys.rqScriptCreate (
V_NAME          VARCHAR2    IN
V_SCRIPT        CLOB        IN
V_GLOBAL        BOOLEAN     IN     DEFAULT
V_OVERWRITE     BOOLEAN     IN     DEFAULT)

パラメータ

説明

V_NAME

Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前。

V_SCRIPT

スクリプトに保存するR関数定義。

V_GLOBAL

TRUEは、スクリプトがパブリックであることを示します。FALSEは、スクリプトがプライベートであることを示します。

V_OVERWRITE

Rスクリプト・リポジトリにV_NAMEと同じ名前のスクリプトがすでにある場合、TRUEではそのスクリプトの内容がV_SCRIPTに置き換えられ、FALSEでは置き換えられません。

関連項目:

SQL APIによるスクリプトの作成

SQLでのスクリプトの管理

A.9 sys.rqScriptDropプロシージャ

sys.rqScriptDropプロシージャは、Oracle R EnterpriseのRスクリプト・リポジトリからスクリプトを削除します。

構文

sys.rqScriptCreate (
V_NAME          VARCHAR2    IN
V_GLOBAL        BOOLEAN     IN     DEFAULT
V_SILENT        BOOLEAN     IN     DEFAULT)

パラメータ

説明

V_NAME

Oracle R EnterpriseのRスクリプト・リポジトリ内のスクリプトの名前。

V_GLOBAL

TRUEは、スクリプトがパブリックであることを示します。FALSEは、スクリプトがプライベートであることを示します。

V_SILENT

Rスクリプト・リポジトリにV_NAMEと同じ名前のスクリプトがすでにある場合、TRUEではそのスクリプトの内容がV_SCRIPTに置き換えられ、FALSEでは置き換えられません。

関連項目:

SQL APIによるスクリプトの作成

B Oracle R EnterpriseのOracle Databaseビュー

Oracle Databaseには、Oracle R EnterpriseのデータストアおよびOracle R Enterpriseのスクリプト・リポジトリ内のスクリプトに関する情報を格納する様々なデータ・ディクショナリ・ビューがあります。

データストアのビュー

- ALL_RQ_DATASTORES

- RQUSER_DATASTORECONTENTS

- RQUSER_DATASTORELIST

- USER_RQ_DATASTORE_PRIVS

- USER_RQ_DATASTORES

スクリプトのビュー

- ALL_RQ_SCRIPTS

- USER_RQ_SCRIPT_PRIVS

- USER_RQ_SCRIPTS

関連項目:

SQLでのスクリプトの管理

Oracle R EnterpriseのSQL API

B.1 ALL_RQ_DATASTORES

ALL_RQ_DATASTORESは、現行のユーザーが使用可能なデータストアを示します。

列

データ型

Null

説明

DSOWNER

VARCHAR2(256)

NOT NULL

データストアの所有者。

DSNAME

VARCHAR2(128)

NOT NULL

データストアの名前。

NOBJ

NUMBER

NOT NULL

データストア内のオブジェクトの数。

DSSIZE

NUMBER

NOT NULL

データストアのサイズ。

CDATE

DATE

NOT NULL

データストアの作成日。

DESCRIPTION

VARCHAR2(2000)

NULL許可

データストアの説明。

GRANTABLE

VARCHAR2(1)

NOT NULL

データストアへの読取りアクセス権を所有者が別のユーザーに付与できるかどうか。

関連項目:

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

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

B.2 ALL_RQ_SCRIPTS

ALL_RQ_SCRIPTSは、現行のユーザーが使用可能な、Oracle DatabaseのRスクリプト・リポジトリ内のスクリプトを示します。

列

データ型

Null

説明

OWNER

VARCHAR2(256)

NOT NULL

スクリプトの所有者。

NAME

VARCHAR2(128)

NOT NULL

スクリプトの名前。

SCRIPT

CLOB

NOT NULL

スクリプトのR関数。

関連項目:

USER_RQ_SCRIPT_PRIVS

USER_RQ_SCRIPTS

B.3 RQUSER_DATASTORECONTENTS

RQUSER_DATASTORECONTENTSには、Oracle R Enterpriseのデータストアの内容に関する情報が格納されます。

列

データ型

Null

説明

DSNAME

VARCHAR2(128)

NOT NULL

データストアの名前。

OBJNAME

VARCHAR2(128)

NOT NULL

データストア内のオブジェクトの名前。

CLASS

VARCHAR2(128)

NOT NULL

オブジェクトのRクラス。

DSSIZE

NUMBER

NOT NULL

オブジェクトのサイズ。

LENGTH

NUMBER

NOT NULL

オブジェクトのサイズ。

NROW

NUMBER

NULL許可

オブジェクト内の行数。

NCOL

NUMBER

NULL許可

オブジェクト内の列数。

関連項目:

ALL_RQ_DATASTORES

RQUSER_DATASTORELIST

B.4 RQUSER_DATASTORELIST

RQUSER_DATASTORELISTには、Oracle R Enterpriseのデータストアに関する情報が格納されます。

列

データ型

Null

説明

DSNAME

VARCHAR2(128)

NOT NULL

データストアの名前。

NOBJ

NUMBER

NOT NULL

データストア内のオブジェクトの数。

DSSIZE

NUMBER

NOT NULL

データストアのサイズ。

CDATE

DATE

NOT NULL

データストアが作成された日付。

DESCRIPTION

VARCHAR2(2000)

NULL許可

データストアの説明。

関連項目:

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

Oracle R EnterpriseのOracle Databaseビュー

ALL_RQ_DATASTORES

B.5 USER_RQ_DATASTORE_PRIVS

USER_RQ_DATASTORE_PRIVSは、データストア、および現行のユーザーが読取りアクセス権を付与したユーザーを示します。

列

データ型

Null

説明

DSNAME

VARCHAR2(128)

NOT NULL

データストアの名前。

GRANTEE

VARCHAR2(30)

NOT NULL

読取りアクセス権が付与されたユーザー。

関連項目:

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

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

ALL_RQ_DATASTORES

USER_RQ_DATASTORES

B.6 USER_RQ_DATASTORES

USER_RQ_DATASTORESは、現行のユーザーが作成したデータストアを示します。

列

データ型

Null

説明

DSNAME

VARCHAR2(128)

NOT NULL

データストアの名前。

NOBJ

NUMBER

NOT NULL

データストア内のオブジェクトの数。

DSSIZE

NUMBER

NOT NULL

データストアのサイズ。

CDATE

DATE

NOT NULL

データストアの作成日。

DESCRIPTION

VARCHAR2(2000)

NULL許可

データストアの説明。

GRANTABLE

VARCHAR2(1)

NOT NULL

データストアへの読取りアクセス権を所有者が別のユーザーに付与できるかどうか。

関連項目:

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

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

ALL_RQ_DATASTORES

USER_RQ_DATASTORE_PRIVS

B.7 USER_RQ_SCRIPT_PRIVS

USER_RQ_SCRIPT_PRIVSは、現行のユーザーが読取りアクセス権を付与したOracle DatabaseのRスクリプト・リポジトリ内のスクリプトおよびアクセス権が付与されたユーザーを示します。

列

データ型

Null

説明

NAME

VARCHAR2(128)

NOT NULL

読取りアクセス権が付与されたスクリプトの名前。

GRANTEE

VARCHAR2(128)

NOT NULL

読取りアクセス権が付与されたユーザー。

関連項目:

ALL_RQ_SCRIPTS

USER_RQ_SCRIPTS

B.8 USER_RQ_SCRIPTS

USER_RQ_SCRIPTSは、現行のユーザーが所有している、Oracle DatabaseのRスクリプト・リポジトリ内のスクリプトを示します。

列

データ型

Null

説明

NAME

VARCHAR2(128)

NOT NULL

スクリプトの名前。

SCRIPT

CLOB

NOT NULL

スクリプトのR関数。

関連項目:

ALL_RQ_SCRIPTS

USER_RQ_SCRIPT_PRIVS

C 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

- アクセス制御

- データストア 1 , 2

- スクリプト 1 , 2

- アクセッサ関数 1

- 集計関数 1 , 3

- データの集計 1

- 集計関数 1

- ALL_RQ_DATASTORESビュー 1

- ALL_RQ_SCRIPTSビュー 1

- Aprioriアルゴリズム 1

- arima関数 1

- arulesパッケージ 1

- as.Date関数 1

- as.difftime関数 1

- as.integer関数 1

- as.ore.character関数 1 , 2

- as.ore.date関数 1

- as.oreクラス 1

- as.ore関数 1

- 相関モデル 1

- スキーマのアタッチ 1

- 属性評価モデル 1

C

- C50パッケージ 1 , 2 , 3 , 4 , 5

- クラスの継承 1

- クラス・タイプの強制変換 1

- 列

- 導出 1

- パーティショニング 1

- データの結合 1

- Comprehensive R Archive Network

- 「CRANパッケージ」を参照

- Rセッションの接続 1

- 接続, 指定 1

- 接続タイプ 1

- 埋込みRの実行用の制御引数 1

- CRANパッケージ 1 , 2 , 3 , 4 , 5 , 6

- 表の作成 1

- プロキシ・オブジェクトの作成 1

- 交差検定モデル 1

D

- データ

- 分布分析 1

- 探索 1

- 索引付け 1

- 結合 1

- パーティショニング 1

- 準備 1 , 2

- ランキング 1

- サンプリング 1

- スコアリング 1

- 選択 1

- ソート 1

- 集計 1 , 2

- 変換 1

- データストア

- 概要 1

- アクセス制御 1

- 削除 1

- 情報の取得 1

- 埋込みRの実行 1 , 2 , 3 , 4 , 5

- SQLでの管理 1

- オブジェクトのリストア 1

- オブジェクトの保存 1 , 2

- 共有 1 , 2

- データ型

- BLOBおよびCLOB 1

- データ型

- 別の型への強制変換 1

- 日付および時間オブジェクト 1

- DCLI 1

- ディシジョン・ツリー・アルゴリズム 1

- ディシジョン・ツリー・モデル 1

- demo関数 1

- デモ 1

- スキーマのデタッチ 1

- diff関数 1

- do.call関数 1

- 表の削除 1

E

- e1071パッケージ 1

- 簡易接続文字列, 指定 1

- 埋込みRの実行

- 概要 1

- API 1

- 制御引数 1

- パラレル実行 1 , 2

- Rインタフェース 1

- セキュリティ 1

- SQLインタフェース 1

- スクリプト例 1

- SQL文の実行 1

- 探索的データ分析

- 例のデータセット 1

- 指数平滑化モデル 1

F

- データのフィルタ処理 1

- forecastパッケージ 1

- データのフォーマット 1

G

- 一般化線形モデル 1 , 2

- glm関数 1

- グローバル・オプション

- ore.envAsEmptyenv 1

- ore.na.extract 1

- ore.parallel 1

- ore.sep 1

- ore.trace 1

- ore.warn.order 1

H

- Hadoopクラスタ 1

- HIVE接続タイプ 1

I

- データの索引付け 1

- install.packages関数 1

- IRLSアルゴリズム 1

- is.null関数 1

K

- kernlabパッケージ 1 , 2

- 鍵

- 順序付け 1

- k-Meansモデル 1

- kyphosisデータセット 1

L

- lapply関数 1

- 最小二乗回帰 1

- ライブラリ関数 1

- 線形回帰モデル 1

- longleyデータセット 1

M

- マップ/リデュース処理 1

- max関数 1

- min関数 1

- 最小記述長アルゴリズム 1

- モデル

- 相関 1

- 属性評価 1

- 交差検定 1

- ディシジョン・ツリー 1

- 一般化線形 1 , 2

- k-Means 1

- 線形回帰 1

- Naive Bayes 1

- ニューラル・ネットワーク 1

- Non-Negative Matrix Factorization 1

- Oracle Data Mining 1

- 直交パーティショニング・クラスタ 1

- パラメトリック 1

- 予測 1

- randomForest 1

- サポート・ベクター・マシン 1

N

- Naive Bayesモデル 1

- ネーミング規則 1

- NARROWデータセット 1

- ニューラル・ネットワーク・モデル 1 , 2

- NMFモデル 1

O

- O-Clusterモデル 1

- オープン・ソースRパッケージ 1 , 2

- Oracle Advanced Analytics 1

- ORACLE接続タイプ 1

- Oracle Data Miningモデル 1 , 2

- Oracle R Advanced Analytics for Hadoop 1

- Oracleウォレット 1 , 2

- ore.frameオブジェクトの順序付け 1 , 2

- ore.attach関数 1 , 2

- ore.characterオブジェクト 1

- 埋込みRの実行用のore.connect制御引数 1

- ore.connect関数 1

- ore.corr関数 1 , 2

- ore.create関数 1

- ore.crosstab関数 1 , 2

- ore.CV関数 1

- ore.datastore関数 1 , 2

- ore.datastoreSummary関数 1 , 2

- ore.dateオブジェクト 1

- ore.datetimeオブジェクト 1

- ore.delete関数 1 , 2

- ore.detach関数 1

- ore.disconnect関数 1 , 2

- ore.doEval関数 1

- 埋込みRの実行用のore.drop制御引数 1

- ore.drop関数 1

- 埋込みRの実行用のore.envAsEmptyenv制御引数 1

- ore.envAsEmptyenvグローバル・オプション 1

- ore.esm関数 1 , 2

- ore.exec関数 1 , 2

- ore.exists関数 1

- ore.frameオブジェクト

- 概要 1

- 表のプロキシ 1

- 列のネーミング規則 1

- 順序付け 1

- data.frameのサブクラス 1

- ore.freq関数 1 , 2

- ore.get関数 1

- ore.glm関数 1 , 2

- ore.grant 1

- ore.grant関数 1 , 2

- 埋込みRの実行用のore.graphics制御引数 1

- ore.groupApply関数 1 , 2 , 3

- ore.hour関数 1

- ore.indexApply関数 1

- ore.integerオブジェクト 1

- ore.is.connected関数 1

- ore.lazyLoad関数 1

- ore.listクラス 1

- ore.lm関数 1 , 2

- ore.load関数 1 , 2

- ore.logicalクラス 1

- ore.ls関数 1

- ore.mday関数 1

- ore.minute関数 1

- ore.month関数 1

- ore.na.extractグローバル・オプション 1

- 埋込みRの実行用のore.na.omit制御引数 1

- ore.neural関数 1 , 2

- ore.odmAI関数 1

- ore.odmAssocRules関数 1

- ore.odmDT関数 1

- ore.odmGLM関数 1

- ore.odmKM関数 1

- ore.odmNB関数 1

- ore.odmNMF関数 1

- ore.odmOC関数 1

- ore.odmSVM関数 1

- ore.parallelグローバル・オプション 1

- 埋込みRの実行用のore.png制御引数 1

- ore.pull関数 1 , 2 , 3

- ore.push関数 1 , 2 , 3

- ore.randomForest関数 1

- ore.rank関数 1 , 2

- ore.revoke 1 , 2

- ore.revoke関数 1

- ore.rm関数 1

- ore.rollmean関数 1

- ore.rollsd関数 1

- ore.rowApply関数 1

- ore.save関数 1 , 3 , 4

- ore.scriptCreate関数 1

- ore.scriptDrop関数 1

- ore.scriptList関数 1

- ore.scriptLoad関数 1

- ore.second関数 1

- ore.sepグローバル・オプション 1 , 2

- ore.sort関数 1 , 2

- ore.stepwise関数 1 , 2

- ore.summary関数

- リリース1.5での変更点 1

- ore.sync関数 1 , 3 , 4 , 5 , 6

- ore.tableApply関数 1

- ore.traceグローバル・オプション 1

- ore.univariate関数 1 , 2

- ore.warn.orderグローバル・オプション 1 , 2

- ore.year関数 1

- OREbaseパッケージ 1

- OREdmパッケージ 1 , 2

- OREedaパッケージ 1

- OREgraphicsパッケージ 1

- OREmodelsパッケージ 1

- OREpredictパッケージ 1

- OREstatsパッケージ 1

P

- パッケージ

- arules 1

- C50 1 , 2 , 3 , 4 , 5

- e1071 1

- forecast 1

- kernlab 1 , 2

- Oracle R Enterprise 1

- ORE 1

- OREbase 1

- OREdm 1 , 2

- OREeda 1

- OREgraphics 1

- OREmodels 1

- OREpredict 1

- OREstats 1

- rpart 1

- statmod 1

- サード・パーティ 1 , 2

- TTR 1

- パラレル実行 1 , 2

- パラメトリック・モデル 1

- プロキシ・オブジェクトの永続化 1

- PL/SQLプロシージャ

- rqDropDataStore 1

- rqGrant 1

- rqRevoke 1

- sys.rqScriptCreate 1

- sys.rqScriptDrop 1

- prcomp関数 1

- データの準備

- 時系列 1

- 主キー

- 順序付け 1

- 主要コンポーネント分析 1

- princomp関数 1

- プロキシ・オブジェクト

- データベース表 1

Q

- quantile関数 1

R

- randomForestモデル 1

- range関数 1

- rbind関数 1

- 回帰モデル 1

- プロキシ・オブジェクトの削除 1

- リポジトリ, Rスクリプト 1

- 行名

- 順序付け 1

- rpartパッケージ 1

- RQADMINロール 1

- rqDropDataStoreプロシージャ 1

- rqEval関数 1 , 2

- rqGrantプロシージャ 1

- rqGroupEval関数 1 , 2

- rqRevokeプロシージャ 1

- rqRowEval関数 1 , 2

- rqTableEval関数 1 , 2

- RQUSER_DATASTORECONTENTSビュー 1

- RQUSER_DATASTORELISTビュー 1

- Rスクリプト・リポジトリ 1 , 2

S

- sample関数 1 , 4

- サンプル・プログラム 1

- サンプリング

- クラスタ 1

- インデータベース・データ 1

- 割当て 1

- 層別 1

- オブジェクトの保存 1

- スキーマ

- アタッチ 1

- デフォルト 1

- デタッチ 1

- データのスコアリング 1

- スクリプト・リポジトリ 1

- スクリプト

- 削除 1

- 埋込みRの実行 1

- 例 1

- データベースでの実行 1

- SQLでの管理 1

- 共有 1 , 2

- 検索パス

- 環境の追加 1

- スキーマの削除 1

- 埋込みRの実行スクリプトのセキュリティ 1

- seq関数 1 , 2

- 特異値分解 1

- sort関数 1

- 埋込みRの実行用のSQL関数 1

- SQL文, 実行 1

- SQL表関数 1

- statmodパッケージ 1

- ステップワイズ最小二乗回帰 1

- summary関数 1

- サポートされるR演算子およびR関数 1

- svd関数 1

- SVMモデル 1

- データベース表の同期 1

- sys.rqScriptCreateプロシージャ 1

- sys.rqScriptDropプロシージャ 1

T

- 表関数 1

- 表

- データベースの作成 1

- データベースの削除 1

- Rでの表示 1

- プロキシ・オブジェクト 1

- サード・パーティのパッケージ 1 , 2 , 3

- transform関数

- 例 1

- 透過層 1 , 2 , 3

- ts関数 1

- TTRパッケージ 1

U

- unique関数 1

- ore.syncのuse.keys引数 1

- USER_RQ_DATASTORE_PRIVSビュー 1

- USER_RQ_DATASTORESビュー 1

- USER_RQ_SCRIPT_PRIVSビュー 1

- USER_RQ_SCRIPTSビュー 1

V

- ビュー

- ALL_RQ_DATASTORES 1

- ALL_RQ_SCRIPTS 1

- Rでの表示 1

- RQUSER_DATASTORECONTENTS 1

- RQUSER_DATASTORELIST 1

- USER_RQ_DATASTORE_PRIVS 1

- USER_RQ_DATASTORES 1

- USER_RQ_SCRIPT_PRIVS 1

- USER_RQ_SCRIPTS 1

W

- ウォレット, Oracle 1 , 2

- ウィンドウ関数 1

オラクルの法律上の注意点について

コピーライトについて

Copyright © 1994-2017, Oracle and/or its affiliates. All rights reserved.

ライセンス制約の保証と結果的に生じる損害の免責

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

保証免責

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

制限付権利について

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

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 Corporationおよびその関連会社は一切の責任を負いかねます。

商標と登録商標について

OracleおよびJavaはオラクルおよびその関連会社の登録商標です。その他の社名、商品名等は各社の商標または登録商標である場合があります。

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

第三者のコンテンツ、製品、サービスに対する免責事項

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

アルファ版およびベータ版ドラフト・ドキュメントについて

このドキュメントが試作版の場合:

このドキュメントは試作版であり、デモおよび暫定使用のみを目的としたものです。このソフトウェアを使用するハードウェアに限定するものではありません。Oracle Corporationおよびその関連会社は、このドキュメントに関して一切の責任を負わず、いかなる保証もいたしません。また、このドキュメントを使用したことによって損失、費用、あるいは損害が発生しても、一切の責任を負いかねます。

非公開のアルファ版およびベータ版ドラフト・ドキュメントについて

このドキュメントが非公開の試作版の場合:

このドキュメントに含まれる情報は、情報の共有のみを目的としたものであって、顧客諮問委員会(Customer Advisory Board)のメンバーとしてのお客様の立場でのみ、またはお客様のベータ・トライアル契約のみに従って検討されるべきものとします。マテリアル、コード、または機能の提供をお約束するものではなく、購入決定を行う際の判断材料とすべきではありません。このドキュメントに記載されている特徴または機能の開発、リリースおよび時期については、オラクルの裁量により決定されます。

このドキュメントには、ソフトウェアまたは印刷物などの形式を問わず、オラクルが独占的な権利を有する財産的情報が含まれています。この機密資料へのアクセスと使用は、お客様とオラクルとの間で締結され、お客様が遵守に同意した、Oracle Master Agreement、Oracle License and Oracle Services Agreement (オラクル・ライセンスおよびサービスに関する契約書)、Oracle PartnerNetwork Agreement、Oracle Distribution Agreementまたはその他のライセンス契約の条件に従うものとします。このドキュメントとその内容の開示、コピー、複製および配布には、オラクルによる事前の承諾を必要とします。このドキュメントはライセンス契約の一部となるものではなく、オラクルおよびその子会社や関連会社との契約を構成するものではありません。

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

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

Oracle Supportへのアクセス

サポートをご契約のお客様には、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を参照してください。