R-quick-guide
R-概要
Rは、統計分析、グラフィックス表現、およびレポート作成のためのプログラミング言語およびソフトウェア環境です。 Rは、ニュージーランドのオークランド大学でRoss IhakaとRobert Gentlemanによって作成され、現在R Development Core Teamによって開発されています。
Rのコアは、関数を使用したモジュール式プログラミングだけでなく、分岐とループを可能にするインタープリター型コンピューター言語です。 Rを使用すると、C、C＆plus;＆plus;、。Net、Python、またはFORTRAN言語で記述された手順と統合して効率を高めることができます。
RはGNU General Public Licenseの下で無料で入手でき、Linux、Windows、Macなどのさまざまなオペレーティングシステム用に、コンパイル済みのバイナリバージョンが提供されています。
Rは、GNUスタイルのコピーを残して配布されるフリーソフトウェアであり、 GNU S と呼ばれるGNUプロジェクトの公式部分です。
Rの進化
Rは、ニュージーランドのオークランドにあるオークランド大学統計学部の Ross Ihaka および Robert Gentleman によって最初に書かれました。 Rは1993年に初めて登場しました。
- 個人の大規模なグループは、コードとバグレポートを送信することでRに貢献しています。
- 1997年半ば以降、Rソースコードアーカイブを変更できるコアグループ（「Rコアチーム」）が存在します。
Rの特徴
前述のように、Rは、統計分析、グラフィックス表現、およびレポート用のプログラミング言語およびソフトウェア環境です。 以下は、Rの重要な特徴です-
- Rは、条件、ループ、ユーザー定義の再帰関数、入出力機能を含む、よく開発されたシンプルで効果的なプログラミング言語です。
- Rには、効果的なデータ処理および保管機能があり、
- Rは、配列、リスト、ベクトル、行列の計算のための一連の演算子を提供します。
- Rは、データ分析のための大規模で一貫性のある統合されたツールのコレクションを提供します。
- Rは、データ分析のためのグラフィック機能を提供し、コンピューターで直接表示するか、論文で印刷します。
結論として、Rは世界で最も広く使用されている統計プログラミング言語です。 これはデータサイエンティストの第1位の選択肢であり、貢献者の活気に満ちた才能のあるコミュニティによってサポートされています。 Rは大学で教えられ、ミッションクリティカルなビジネスアプリケーションで展開されます。 このチュートリアルでは、Rプログラミングと適切な例を簡単で簡単な手順で説明します。
R-環境設定
ローカル環境のセットアップ
引き続きRの環境をセットアップする場合は、以下の手順を実行できます。
Windowsインストール
RのWindowsインストーラーバージョンをhttps://cran.r-project.org/bin/windows/base/[R-3.2.2 for Windows（32/64ビット）]からダウンロードして、ローカルディレクトリに保存できます。 。
「R-version-win.exe」という名前のWindowsインストーラー（.exe）です。 ダブルクリックしてインストーラーを実行し、デフォルト設定を受け入れます。 Windowsが32ビットバージョンの場合、32ビットバージョンがインストールされます。 ただし、Windowsが64ビットの場合、32ビットバージョンと64ビットバージョンの両方がインストールされます。
インストール後、Windows Program Filesの下のディレクトリ構造「R \ R3.2.2 \ bin \ i386 \ Rgui.exe」でプログラムを実行するアイコンを見つけることができます。 このアイコンをクリックすると、Rプログラミングを行うためのRコンソールであるR-GUIが表示されます。
Linuxのインストール
Rは、https://cran.r-project.org/bin/linux/[R Binaries]からLinuxの多くのバージョンのバイナリとして入手できます。
Linuxのインストール手順は、フレーバーごとに異なります。 これらの手順は、記載されているリンクのLinuxバージョンの各タイプの下に記載されています。 ただし、急いでいる場合は、次のように yum コマンドを使用してRをインストールできます-
$ yum install R上記のコマンドは、標準パッケージとともにRプログラミングのコア機能をインストールしますが、追加のパッケージが必要な場合は、次のようにRプロンプトを起動できます-
$ R
R version 3.2.0 (2015-04-16) -- "Full of Ingredients"
Copyright (C) 2015 The R Foundation for Statistical Computing
Platform: x86_64-redhat-linux-gnu (64-bit)
R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.
R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.
Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.
>これで、Rプロンプトでinstallコマンドを使用して、必要なパッケージをインストールできます。 たとえば、次のコマンドは3Dチャートに必要な plotrix パッケージをインストールします。
> install.packages("plotrix")R-基本的な構文
慣例として、「Hello、World！」と書くことでRプログラミングの学習を開始します。プログラム。 ニーズに応じて、Rコマンドプロンプトでプログラムするか、Rスクリプトファイルを使用してプログラムを作成できます。 両方を1つずつ確認しましょう。
Rコマンドプロンプト
R環境をセットアップしたら、コマンドプロンプトで次のコマンドを入力するだけでRコマンドプロンプトを簡単に起動できます-
$ Rこれにより、Rインタプリタが起動し、プロンプトが表示されます。次のようにプログラムの入力を開始できます-
> myString <- "Hello, World!"
> print ( myString)
[1] "Hello, World!"ここで、最初のステートメントは、ストリング変数myStringを定義します。ここで、ストリング「Hello、World！」を割り当てます。次に、次のステートメントprint（）を使用して、変数myStringに格納されている値を出力しています。
Rスクリプトファイル
通常、プログラムをスクリプトファイルに記述してプログラミングを行い、コマンドプロンプトで Rscript と呼ばれるRインタープリターを使用してそれらのスクリプトを実行します。 だから、次のようにtest.Rと呼ばれるテキストファイルに次のコードを書くことから始めましょう-
# My first program in R Programming
myString <- "Hello, World!"
print ( myString)上記のコードをファイルtest.Rに保存し、以下のようにLinuxコマンドプロンプトで実行します。 Windowsまたは他のシステムを使用している場合でも、構文は変わりません。
$ Rscript test.R上記のプログラムを実行すると、次の結果が生成されます。
[1] "Hello, World!"コメント
コメントは、Rプログラムのテキストを支援するようなものであり、実際のプログラムの実行中はインタープリターによって無視されます。 単一のコメントは、次のようにステートメントの先頭に＃を使用して書き込まれます-
# My first program in R ProgrammingRは複数行のコメントをサポートしていませんが、次のようなトリックを実行できます-
if(FALSE) {
"This is a demo for multi-line comments and it should be put inside either a
single OR double quote"
}
myString <- "Hello, World!"
print ( myString)[1] "Hello, World!"上記のコメントはRインタプリタによって実行されますが、実際のプログラムに干渉することはありません。 このようなコメントは、一重引用符または二重引用符で囲む必要があります。
R-データ型
一般に、プログラミング言語でプログラミングを行う際には、さまざまな変数を使用してさまざまな情報を保存する必要があります。 変数は、値を保存するために予約されたメモリの場所に他なりません。 これは、変数を作成するときに、メモリの一部の領域を予約することを意味します。
文字、ワイド文字、整数、浮動小数点、二重浮動小数点、ブールなどのさまざまなデータ型の情報を保存することができます。 変数のデータ型に基づいて、オペレーティングシステムはメモリを割り当て、予約メモリに保存できるものを決定します。
RのCやjavaなどの他のプログラミング言語とは対照的に、変数は何らかのデータ型として宣言されていません。 変数にはRオブジェクトが割り当てられ、Rオブジェクトのデータ型は変数のデータ型になります。 Rオブジェクトには多くの種類があります。 頻繁に使用されるものは-
- ベクトル
- リスト
- 行列
- 配列
- 要因
- データフレーム
これらのオブジェクトの中で最も単純なものは* vectorオブジェクト*であり、これらのアトミックベクトルには6つのデータ型があり、6つのクラスのベクトルとも呼ばれます。 他のRオブジェクトは、アトミックベクトルに基づいて構築されます。
| Data Type | Example | Verify |
|---|---|---|
| Logical | TRUE, FALSE |
それは次の結果を生成します- |
| Numeric | 12.3, 5, 999 |
それは次の結果を生成します- |
| Integer | 2L, 34L, 0L |
それは次の結果を生成します- |
| Complex | 3 PLUS 2i |
それは次の結果を生成します- |
| Character | 'a' , '"good", "TRUE", '23.4' |
それは次の結果を生成します- |
| Raw | "Hello" is stored as 48 65 6c 6c 6f |
それは次の結果を生成します- |
Rプログラミングでは、非常に基本的なデータ型は vectors と呼ばれるRオブジェクトであり、上記のように異なるクラスの要素を保持します。 Rでは、クラスの数が上記の6つのタイプだけに限定されないことに注意してください。 たとえば、多くのアトミックベクトルを使用して、クラスが配列になる配列を作成できます。
ベクトル
複数の要素を含むベクターを作成する場合は、* c（）*関数を使用して、要素をベクターに結合する必要があります。
# Create a vector.
apple <- c('red','green',"yellow")
print(apple)
# Get the class of the vector.
print(class(apple))上記のコードを実行すると、次の結果が生成されます-
[1] "red" "green" "yellow"
[1] "character"リスト
リストは、ベクトル、関数、さらには別のリストなど、さまざまなタイプの要素を含むことができるRオブジェクトです。
# Create a list.
list1 <- list(c(2,5,3),21.3,sin)
# Print the list.
print(list1)上記のコードを実行すると、次の結果が生成されます-
[[function (x) .Primitive("sin")行列
マトリックスは、2次元の長方形のデータセットです。 行列関数へのベクトル入力を使用して作成できます。
# Create a matrix.
M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)上記のコードを実行すると、次の結果が生成されます-
[,1] [,2] [,3]
[1,] "a" "a" "b"
[2,] "c" "b" "a"配列
行列は2次元に制限されていますが、配列は任意の次元数にすることができます。 配列関数は、必要な次元数を作成するdim属性を取ります。 以下の例では、それぞれ3x3のマトリックスである2つの要素を持つ配列を作成します。
# Create an array.
a <- array(c('green','yellow'),dim = c(3,3,2))
print(a)上記のコードを実行すると、次の結果が生成されます-
, , 1
[,1] [,2] [,3]
[1,] "green" "yellow" "green"
[2,] "yellow" "green" "yellow"
[3,] "green" "yellow" "green"
, , 2
[,1] [,2] [,3]
[1,] "yellow" "green" "yellow"
[2,] "green" "yellow" "green"
[3,] "yellow" "green" "yellow"要因
因子は、ベクトルを使用して作成されるrオブジェクトです。 ラベルとしてベクトル内の要素の個別の値とともにベクトルを保存します。 ラベルは、数値、文字、ブールなどに関係なく、常に文字です。 入力ベクトル内。 これらは統計モデリングに役立ちます。
因子は* factor（）関数を使用して作成されます。 *nlevels 関数は、レベルのカウントを提供します。
# Create a vector.
apple_colors <- c('green','green','yellow','red','red','red','green')
# Create a factor object.
factor_apple <- factor(apple_colors)
# Print the factor.
print(factor_apple)
print(nlevels(factor_apple))上記のコードを実行すると、次の結果が生成されます-
[1] green green yellow red red red green
Levels: green red yellow
[1] 3データフレーム
データフレームは表形式のデータオブジェクトです。 データフレームのマトリックスとは異なり、各列には異なるモードのデータを含めることができます。 最初の列は数値、2番目の列は文字、3番目の列は論理値にすることができます。 等しい長さのベクトルのリストです。
データフレームは、* data.frame（）*関数を使用して作成されます。
# Create the data frame.
BMI <- data.frame(
gender = c("Male", "Male","Female"),
height = c(152, 171.5, 165),
weight = c(81,93, 78),
Age = c(42,38,26)
)
print(BMI)上記のコードを実行すると、次の結果が生成されます-
gender height weight Age
1 Male 152.0 81 42
2 Male 171.5 93 38
3 Female 165.0 78 26R-変数
変数は、プログラムが操作できる名前付きストレージを提供します。 Rの変数は、原子ベクトル、原子ベクトルのグループ、または多くのRobjectの組み合わせを格納できます。 有効な変数名は、文字、数字、ドットまたは下線文字で構成されます。 変数名は、文字で始まるか、数字が続かないドットで始まります。
| Variable Name | Validity | Reason |
|---|---|---|
| var_name2. | valid | Has letters, numbers, dot and underscore |
| var_name% | Invalid | Has the character '%'. Only dot(.) and underscore allowed. |
| 2var_name | invalid | Starts with a number |
|
var_name,. var.name |
valid | Can start with a dot(.) but the dot(.)should not be followed by a number. |
| .2var_name | invalid | The starting dot is followed by a number making it invalid. |
| _var_name | invalid | Starts with _ which is not valid |
変数の割り当て
変数には、左向き、右向き、および等しい演算子を使用して値を割り当てることができます。 変数の値は、* print（）または cat（）*関数を使用して出力できます。 * cat（）*関数は、複数のアイテムを連続印刷出力に結合します。
# Assignment using equal operator.
var.1 = c(0,1,2,3)
# Assignment using leftward operator.
var.2 <- c("learn","R")
# Assignment using rightward operator.
c(TRUE,1) -> var.3
print(var.1)
cat ("var.1 is ", var.1 ,"\n")
cat ("var.2 is ", var.2 ,"\n")
cat ("var.3 is ", var.3 ,"\n")上記のコードを実行すると、次の結果が生成されます-
[1] 0 1 2 3
var.1 is 0 1 2 3
var.2 is learn R
var.3 is 1 1注-ベクトルc（TRUE、1）には、論理クラスと数値クラスが混在しています。 したがって、論理クラスは数値クラスに強制され、TRUEが1になります。
変数のデータ型
Rでは、変数自体はどのデータ型でも宣言されず、R-オブジェクトに割り当てられたオブジェクトのデータ型を取得します。 したがって、Rは動的に型指定された言語と呼ばれます。つまり、プログラムで変数を使用するときに、同じ変数の変数のデータ型を何度も変更できます。
var_x <- "Hello"
cat("The class of var_x is ",class(var_x),"\n")
var_x <- 34.5
cat(" Now the class of var_x is ",class(var_x),"\n")
var_x <- 27L
cat(" Next the class of var_x becomes ",class(var_x),"\n")上記のコードを実行すると、次の結果が生成されます-
The class of var_x is character
Now the class of var_x is numeric
Next the class of var_x becomes integer変数を見つける
ワークスペースで現在使用可能なすべての変数を知るには、* ls（）*関数を使用します。 また、ls（）関数は、パターンを使用して変数名を照合できます。
print(ls())上記のコードを実行すると、次の結果が生成されます-
[1] "my var" "my_new_var" "my_var" "var.1"
[5] "var.2" "var.3" "var.name" "var_name2."
[9] "var_x" "varname"注-環境で宣言されている変数に応じたサンプル出力です。
ls（）関数は、パターンを使用して変数名を照合できます。
# List the variables starting with the pattern "var".
print(ls(pattern = "var"))上記のコードを実行すると、次の結果が生成されます-
[1] "my var" "my_new_var" "my_var" "var.1"
[5] "var.2" "var.3" "var.name" "var_name2."
[9] "var_x" "varname"- dot（。）*で始まる変数は非表示になり、ls（）関数の「all.names = TRUE」引数を使用してリストできます。
print(ls(all.name = TRUE))上記のコードを実行すると、次の結果が生成されます-
[1] ".cars" ".Random.seed" ".var_name" ".varname" ".varname2"
[6] "my var" "my_new_var" "my_var" "var.1" "var.2"
[11]"var.3" "var.name" "var_name2." "var_x"変数を削除する
- rm（）*関数を使用して、変数を削除できます。 以下では、変数var.3を削除します。 印刷時に、変数errorの値がスローされます。
rm(var.3)
print(var.3)上記のコードを実行すると、次の結果が生成されます-
[1] "var.3"
Error in print(var.3) : object 'var.3' not foundすべての変数は、* rm（）関数と ls（）*関数を一緒に使用して削除できます。
rm(list = ls())
print(ls())上記のコードを実行すると、次の結果が生成されます-
character(0)R-演算子
演算子は、特定の数学的または論理的な操作を実行するようコンパイラーに指示する記号です。 R言語には組み込みの演算子が豊富で、次の種類の演算子が用意されています。
演算子の種類
Rプログラミングには次のタイプの演算子があります-
- 算術演算子
- 関係演算子
- 論理演算子
- 割り当て演算子
- その他の演算子
算術演算子
次の表に、R言語でサポートされている算術演算子を示します。 演算子は、ベクトルの各要素に作用します。
| Operator | Description | Example |
|---|---|---|
| PLUS | Adds two vectors |
それは次の結果を生成します- |
| − | Subtracts second vector from the first |
それは次の結果を生成します- |
| * | Multiplies both vectors |
それは次の結果を生成します- |
| / | Divide the first vector with the second |
上記のコードを実行すると、次の結果が生成されます- |
| %% | Give the remainder of the first vector with the second |
それは次の結果を生成します- |
| %/% | The result of division of first vector with second (quotient) |
それは次の結果を生成します- |
| ^ | The first vector raised to the exponent of second vector |
それは次の結果を生成します- |
関係演算子
次の表に、R言語でサポートされている関係演算子を示します。 最初のベクトルの各要素は、2番目のベクトルの対応する要素と比較されます。 比較の結果はブール値です。
| Operator | Description | Example |
|---|---|---|
| > | Checks if each element of the first vector is greater than the corresponding element of the second vector. |
それは次の結果を生成します- |
| < | Checks if each element of the first vector is less than the corresponding element of the second vector. |
それは次の結果を生成します- |
| == | Checks if each element of the first vector is equal to the corresponding element of the second vector. |
それは次の結果を生成します- |
| ⇐ | Checks if each element of the first vector is less than or equal to the corresponding element of the second vector. |
それは次の結果を生成します- |
| >= | Checks if each element of the first vector is greater than or equal to the corresponding element of the second vector. |
それは次の結果を生成します- |
| != | Checks if each element of the first vector is unequal to the corresponding element of the second vector. |
それは次の結果を生成します- |
論理演算子
次の表に、R言語でサポートされる論理演算子を示します。 論理型、数値型、または複素数型のベクトルにのみ適用できます。 1より大きいすべての数値は、論理値TRUEと見なされます。
最初のベクトルの各要素は、2番目のベクトルの対応する要素と比較されます。 比較の結果はブール値です。
| Operator | Description | Example |
|---|---|---|
| & | It is called Element-wise Logical AND operator. It combines each element of the first vector with the corresponding element of the second vector and gives a output TRUE if both the elements are TRUE. |
それは次の結果を生成します- |
| It is called Element-wise Logical OR operator. It combines each element of the first vector with the corresponding element of the second vector and gives a output TRUE if one the elements is TRUE. | ||
|
t) ---- それは次の結果を生成します- [source,result,notranslate] ---- [1] TRUE FALSE TRUE TRUE ---- |
! |
論理演算子&&および||ベクトルの最初の要素のみを考慮し、出力として単一要素のベクトルを与えます。
| Operator | Description | Example |
|---|---|---|
| && | Called Logical AND operator. Takes first element of both the vectors and gives the TRUE only if both are TRUE. |
それは次の結果を生成します- |
| Called Logical OR operator. Takes first element of both the vectors and gives the TRUE if one of them is TRUE. |
|
割り当て演算子
これらの演算子は、ベクトルに値を割り当てるために使用されます。
| Operator | Description | Example |
|---|---|---|
|
<− or = or <<− |
Called Left Assignment |
それは次の結果を生成します- a |
|
→ or →> |
Called Right Assignment |
それは次の結果を生成します- |
その他の演算子
これらの演算子は、一般的な数学的または論理的な計算ではなく、特定の目的に使用されます。
| Operator | Description | Example |
|---|---|---|
| : | Colon operator. It creates the series of numbers in sequence for a vector. |
それは次の結果を生成します- |
| %in% | This operator is used to identify if an element belongs to a vector. |
それは次の結果を生成します- |
| %*% | This operator is used to multiply a matrix with its transpose. |
それは次の結果を生成します- |
R-意思決定
意思決定構造では、プログラマーは、プログラムが評価またはテストする1つ以上の条件を、条件が true であると判断された場合に実行されるステートメント、およびオプションで次の場合に実行されるステートメントとともに指定する必要があります。条件は false であると判断されます。
以下は、ほとんどのプログラミング言語で見られる典型的な意思決定構造の一般的な形式です-
Rは、以下のタイプの意思決定ステートメントを提供します。 詳細を確認するには、次のリンクをクリックしてください。
| Sr.No. | Statement & Description |
|---|---|
| 1 |
|
| 2 |
|
| 3 |
|
R-ループ
コードのブロックを数回実行する必要がある場合があります。 一般に、ステートメントは順番に実行されます。 関数の最初のステートメントが最初に実行され、次に2番目のステートメントが実行されます。
プログラミング言語は、より複雑な実行パスを可能にするさまざまな制御構造を提供します。
ループステートメントを使用すると、ステートメントまたはステートメントのグループを複数回実行できます。次は、ほとんどのプログラミング言語でのループステートメントの一般的な形式です-
Rプログラミング言語は、ループ要件を処理するために次の種類のループを提供します。 詳細を確認するには、次のリンクをクリックしてください。
| Sr.No. | Loop Type & Description |
|---|---|
| 1 |
一連のステートメントを複数回実行し、ループ変数を管理するコードを短縮します。 |
| 2 |
特定の条件が真の間、ステートメントまたはステートメントのグループを繰り返します。 ループ本体を実行する前に条件をテストします。 |
| 3 |
whileステートメントと似ていますが、ループ本体の最後で条件をテストします。 |
ループ制御ステートメント
ループ制御ステートメントは、通常のシーケンスから実行を変更します。 実行がスコープを離れると、そのスコープで作成されたすべての自動オブジェクトが破棄されます。
Rは、次の制御ステートメントをサポートしています。 詳細を確認するには、次のリンクをクリックしてください。
| Sr.No. | Control Statement & Description |
|---|---|
| 1 |
|
| 2 |
|
R-関数
関数は、特定のタスクを実行するためにまとめられた一連のステートメントです。 Rには多数の組み込み関数があり、ユーザーは独自の関数を作成できます。
Rでは、関数はオブジェクトであるため、Rインタープリターは、関数がアクションを実行するために必要な引数とともに、制御を関数に渡すことができます。
次に、関数はそのタスクを実行し、インタープリターに制御を返します。また、他のオブジェクトに格納される可能性のある結果を返します。
関数定義
R関数は、キーワード function を使用して作成されます。 R関数定義の基本的な構文は次のとおりです-
function_name <- function(arg_1, arg_2, ...) {
Function body
}機能コンポーネント
関数のさまざまな部分は-
- 関数名-これは関数の実際の名前です。 この名前のオブジェクトとしてR環境に保存されます。
- 引数-引数はプレースホルダーです。 関数が呼び出されると、引数に値を渡します。 引数はオプションです。つまり、関数には引数が含まれない場合があります。 また、引数にはデフォルト値を設定できます。
- 関数本体-関数本体には、関数の動作を定義するステートメントのコレクションが含まれています。
- 戻り値-関数の戻り値は、評価される関数本体の最後の式です。
Rには、最初に定義せずにプログラムで直接呼び出すことができる多くの*組み込み*関数があります。 また、*ユーザー定義*関数と呼ばれる独自の関数を作成して使用することもできます。
組み込み関数
組み込み関数の簡単な例は、* seq（）、 mean（）、 max（）、 sum（x）、および paste（…）*などです。 これらは、ユーザー作成プログラムによって直接呼び出されます。 https://cran.r-project.org/doc/contrib/Short-refcard.pdf [最も広く使用されているR関数]を参照できます。
# Create a sequence of numbers from 32 to 44.
print(seq(32,44))
# Find mean of numbers from 25 to 82.
print(mean(25:82))
# Find sum of numbers frm 41 to 68.
print(sum(41:68))上記のコードを実行すると、次の結果が生成されます-
[1] 32 33 34 35 36 37 38 39 40 41 42 43 44
[1] 53.5
[1] 1526ユーザー定義関数
Rでユーザー定義関数を作成できます。 これらはユーザーが望むものに固有のものであり、一度作成すると組み込み関数のように使用できます。 以下は、関数がどのように作成され使用されるかの例です。
# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
for(i in 1:a) {
b <- i^2
print(b)
}
}関数を呼び出す
# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
for(i in 1:a) {
b <- i^2
print(b)
}
}
# Call the function new.function supplying 6 as an argument.
new.function(6)上記のコードを実行すると、次の結果が生成されます-
[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36引数なしで関数を呼び出す
# Create a function without an argument.
new.function <- function() {
for(i in 1:5) {
print(i^2)
}
}
# Call the function without supplying an argument.
new.function()上記のコードを実行すると、次の結果が生成されます-
[1] 1
[1] 4
[1] 9
[1] 16
[1] 25引数値を使用した関数の呼び出し（位置および名前による）
関数呼び出しの引数は、関数で定義されているのと同じ順序で指定するか、別の順序で指定しますが、引数の名前に割り当てることができます。
# Create a function with arguments.
new.function <- function(a,b,c) {
result <- a *b + c
print(result)
}
# Call the function by position of arguments.
new.function(5,3,11)
# Call the function by names of the arguments.
new.function(a = 11, b = 5, c = 3)上記のコードを実行すると、次の結果が生成されます-
[1] 26
[1] 58デフォルト引数で関数を呼び出す
関数定義で引数の値を定義し、引数を指定せずに関数を呼び出してデフォルトの結果を取得できます。 ただし、引数の新しい値を指定してこのような関数を呼び出し、デフォルト以外の結果を取得することもできます。
# Create a function with arguments.
new.function <- function(a = 3, b = 6) {
result <- a* b
print(result)
}
# Call the function without giving any argument.
new.function()
# Call the function with giving new values of the argument.
new.function(9,5)上記のコードを実行すると、次の結果が生成されます-
[1] 18
[1] 45関数の遅延評価
関数への引数は遅延評価されます。つまり、関数本体で必要な場合にのみ評価されます。
# Create a function with arguments.
new.function <- function(a, b) {
print(a^2)
print(a)
print(b)
}
# Evaluate the function without supplying one of the arguments.
new.function(6)上記のコードを実行すると、次の結果が生成されます-
[1] 36
[1] 6
Error in print(b) : argument "b" is missing, with no defaultR-ストリング
Rの単一引用符または二重引用符のペア内に記述された値は、文字列として扱われます。 内部的にRは、単一引用符で作成した場合でも、すべての文字列を二重引用符で囲んで保存します。
文字列の構築に適用されるルール
- 文字列の先頭と末尾の引用符は、両方とも二重引用符か両方とも単一引用符にする必要があります。 それらを混在させることはできません。
- 二重引用符は、単一引用符で開始および終了する文字列に挿入できます。
- 単一引用符は、二重引用符で始まり、二重引用符で終わる文字列に挿入できます。
- 二重引用符で始まり、二重引用符で終わる文字列に二重引用符を挿入することはできません。
- 単一引用符は、単一引用符で始まり、単一引用符で終わる文字列に挿入できません。
有効な文字列の例
次の例は、Rでの文字列の作成に関するルールを明確にします。
a <- 'Start and end with single quote'
print(a)
b <- "Start and end with double quotes"
print(b)
c <- "single quote ' in between double quotes"
print(c)
d <- 'Double quotes " in between single quote'
print(d)上記のコードを実行すると、次の出力が得られます-
[1] "Start and end with single quote"
[1] "Start and end with double quotes"
[1] "single quote ' in between double quote"
[1] "Double quote \" in between single quote"無効な文字列の例
e <- 'Mixed quotes"
print(e)
f <- 'Single quote ' inside single quote'
print(f)
g <- "Double quotes " inside double quotes"
print(g)スクリプトを実行すると、以下の結果が表示されて失敗します。
Error: unexpected symbol in:
"print(e)
f <- 'Single"
Execution halted文字列操作
文字列の連結-paste（）関数
Rの多くの文字列は、* paste（）*関数を使用して結合されます。 任意の数の引数を組み合わせて組み合わせることができます。
構文
貼り付け機能の基本的な構文は次のとおりです-
paste(..., sep = " ", collapse = NULL)以下は、使用されるパラメータの説明です-
- … は、結合される任意の数の引数を表します。
- sep は、引数間の区切り文字を表します。 オプションです。
- collapse は、2つの文字列の間のスペースを削除するために使用されます。 しかし、1つの文字列の2つの単語内のスペースではありません。
例
a <- "Hello"
b <- 'How'
c <- "are you? "
print(paste(a,b,c))
print(paste(a,b,c, sep = "-"))
print(paste(a,b,c, sep = "", collapse = ""))上記のコードを実行すると、次の結果が生成されます-
[1] "Hello How are you? "
[1] "Hello-How-are you? "
[1] "HelloHoware you? "数字と文字列のフォーマット-format（）関数
- format（）*関数を使用して、数字と文字列を特定のスタイルにフォーマットできます。
構文
フォーマット機能の基本的な構文は次のとおりです-
format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none"))以下は、使用されるパラメータの説明です-
- x はベクトル入力です。
- digits は、表示される合計桁数です。
- nsmall は、小数点の右側の最小桁数です。
- 科学表記法を表示するには、 scientific をTRUEに設定します。
- width は、先頭に空白を埋めることによって表示される最小幅を示します。
- justify は、文字列を左、右、または中央に表示します。
例
# Total number of digits displayed. Last digit rounded off.
result <- format(23.123456789, digits = 9)
print(result)
# Display numbers in scientific notation.
result <- format(c(6, 13.14521), scientific = TRUE)
print(result)
# The minimum number of digits to the right of the decimal point.
result <- format(23.47, nsmall = 5)
print(result)
# Format treats everything as a string.
result <- format(6)
print(result)
# Numbers are padded with blank in the beginning for width.
result <- format(13.7, width = 6)
print(result)
# Left justify strings.
result <- format("Hello", width = 8, justify = "l")
print(result)
# Justfy string with center.
result <- format("Hello", width = 8, justify = "c")
print(result)上記のコードを実行すると、次の結果が生成されます-
[1] "23.1234568"
[1] "6.000000e+00" "1.314521e+01"
[1] "23.47000"
[1] "6"
[1] " 13.7"
[1] "Hello "
[1] " Hello "文字列の文字数を数える-nchar（）関数
この関数は、文字列内のスペースを含む文字数をカウントします。
構文
nchar（）関数の基本的な構文は次のとおりです-
nchar(x)以下は、使用されるパラメータの説明です-
- x はベクトル入力です。
例
result <- nchar("Count the number of characters")
print(result)上記のコードを実行すると、次の結果が生成されます-
[1] 30大文字と小文字の変更-toupper（）およびtolower（）関数
これらの関数は、文字列の文字の大文字と小文字を変更します。
構文
toupper（）およびtolower（）関数の基本的な構文は-
toupper(x)
tolower(x)以下は、使用されるパラメータの説明です-
- x はベクトル入力です。
例
# Changing to Upper case.
result <- toupper("Changing To Upper")
print(result)
# Changing to lower case.
result <- tolower("Changing To Lower")
print(result)上記のコードを実行すると、次の結果が生成されます-
[1] "CHANGING TO UPPER"
[1] "changing to lower"文字列の一部の抽出-substring（）関数
この関数は、文字列の一部を抽出します。
構文
substring（）関数の基本的な構文は次のとおりです-
substring(x,first,last)以下は、使用されるパラメータの説明です-
- x は文字ベクトル入力です。
- first は、抽出される最初の文字の位置です。
- last は、抽出される最後の文字の位置です。
例
# Extract characters from 5th to 7th position.
result <- substring("Extract", 5, 7)
print(result)上記のコードを実行すると、次の結果が生成されます-
[1] "act"R-ベクトル
ベクトルは最も基本的なRデータオブジェクトであり、6種類のアトミックベクトルがあります。 論理、整数、倍精度、複素数、文字、および生です。
ベクター作成
単一要素ベクトル
Rに値を1つだけ記述しても、長さ1のベクトルになり、上記のベクトルタイプのいずれかに属します。
# Atomic vector of type character.
print("abc");
# Atomic vector of type double.
print(12.5)
# Atomic vector of type integer.
print(63L)
# Atomic vector of type logical.
print(TRUE)
# Atomic vector of type complex.
print(2+3i)
# Atomic vector of type raw.
print(charToRaw('hello'))上記のコードを実行すると、次の結果が生成されます-
[1] "abc"
[1] 12.5
[1] 63
[1] TRUE
[1] 2+3i
[1] 68 65 6c 6c 6f複数の要素のベクトル
数値データでコロン演算子を使用
# Creating a sequence from 5 to 13.
v <- 5:13
print(v)
# Creating a sequence from 6.6 to 12.6.
v <- 6.6:12.6
print(v)
# If the final element specified does not belong to the sequence then it is discarded.
v <- 3.8:11.4
print(v)上記のコードを実行すると、次の結果が生成されます-
[1] 5 6 7 8 9 10 11 12 13
[1] 6.6 7.6 8.6 9.6 10.6 11.6 12.6
[1] 3.8 4.8 5.8 6.8 7.8 8.8 9.8 10.8シーケンス（Seq。）演算子を使用
# Create vector with elements from 5 to 9 incrementing by 0.4.
print(seq(5, 9, by = 0.4))上記のコードを実行すると、次の結果が生成されます-
[1] 5.0 5.4 5.8 6.2 6.6 7.0 7.4 7.8 8.2 8.6 9.0- c（）関数の使用 *
要素の1つが文字である場合、非文字値は文字タイプに強制されます。
# The logical and numeric values are converted to characters.
s <- c('apple','red',5,TRUE)
print(s)上記のコードを実行すると、次の結果が生成されます-
[1] "apple" "red" "5" "TRUE"ベクター要素へのアクセス
ベクターの要素には、インデックスを使用してアクセスします。* []角括弧*はインデックス作成に使用されます。 インデックス作成は位置1から始まります。 インデックスに負の値を指定すると、その要素がresultから削除されます。 TRUE 、 FALSE 、または 0 および 1 は、インデックス作成にも使用できます。
# Accessing vector elements using position.
t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat")
u <- t[c(2,3,6)]
print(u)
# Accessing vector elements using logical indexing.
v <- t[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE)]
print(v)
# Accessing vector elements using negative indexing.
x <- t[c(-2,-5)]
print(x)
# Accessing vector elements using 0/1 indexing.
y <- t[c(0,0,0,0,0,0,1)]
print(y)上記のコードを実行すると、次の結果が生成されます-
[1] "Mon" "Tue" "Fri"
[1] "Sun" "Fri"
[1] "Sun" "Tue" "Wed" "Fri" "Sat"
[1] "Sun"ベクトル操作
ベクトル演算
同じ長さの2つのベクトルを加算、減算、乗算、または除算して、ベクトル出力として結果を得ることができます。
# Create two vectors.
v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11,0,8,1,2)
# Vector addition.
add.result <- v1+v2
print(add.result)
# Vector subtraction.
sub.result <- v1-v2
print(sub.result)
# Vector multiplication.
multi.result <- v1*v2
print(multi.result)
# Vector division.
divi.result <- v1/v2
print(divi.result)上記のコードを実行すると、次の結果が生成されます-
[1] 7 19 4 13 1 13
[1] -1 -3 4 -3 -1 9
[1] 12 88 0 40 0 22
[1] 0.7500000 0.7272727 Inf 0.6250000 0.0000000 5.5000000ベクター要素のリサイクル
長さが等しくない2つのベクトルに算術演算を適用すると、短いベクトルの要素はリサイクルされて演算が完了します。
v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11)
# V2 becomes c(4,11,4,11,4,11)
add.result <- v1+v2
print(add.result)
sub.result <- v1-v2
print(sub.result)上記のコードを実行すると、次の結果が生成されます-
[1] 7 19 8 16 4 22
[1] -1 -3 0 -6 -4 0ベクター要素の並べ替え
ベクトルの要素は、* sort（）*関数を使用してソートできます。
v <- c(3,8,4,5,0,11, -9, 304)
# Sort the elements of the vector.
sort.result <- sort(v)
print(sort.result)
# Sort the elements in the reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)
# Sorting character vectors.
v <- c("Red","Blue","yellow","violet")
sort.result <- sort(v)
print(sort.result)
# Sorting character vectors in reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)上記のコードを実行すると、次の結果が生成されます-
[1] -9 0 3 4 5 8 11 304
[1] 304 11 8 5 4 3 0 -9
[1] "Blue" "Red" "violet" "yellow"
[1] "yellow" "violet" "Red" "Blue"R-リスト
リストは、数、文字列、ベクトルなどのさまざまなタイプの要素を含むRオブジェクトです。 リストには、要素として行列または関数を含めることもできます。 リストは* list（）*関数を使用して作成されます。
リストを作成する
以下は、文字列、数値、ベクトル、論理値を含むリストを作成する例です。
# Create a list containing strings, numbers, vectors and a logical
# values.
list_data <- list("Red", "Green", c(21,32,11), TRUE, 51.23, 119.1)
print(list_data)上記のコードを実行すると、次の結果が生成されます-
[[Red"
[[Green"
[[TRUE
[[Naming List Elements
The list elements can be given names and they can be accessed using these names.
[source,prettyprint,notranslate]＃ベクトル、マトリックス、リストを含むリストを作成します。 list_data ←list（c（ "Jan"、 "Feb"、 "Mar"）、matrix（c（3,9,5,1、-2,8）、nrow = 2）、list（ "green"、12.3 ））
＃リスト内の要素に名前を付けます。 names（list_data）←c（ "1st Quarter"、 "A_Matrix"、 "A内部リスト"）
＃リストを表示します。 print（list_data）
When we execute the above code, it produces the following result −
[source,result,notranslate]$ 1st_Quarter [1] "Jan" "Feb" "Mar"
$ A_Matrix [、1] [、2] [、3] [1,] 3 5 -2 [2,] 9 1 8
$ A_Inner_list $ A_Inner_list [[green "
$ A_Inner_list [[リスト要素へのアクセス
リストの要素には、リスト内の要素のインデックスを使用してアクセスできます。 名前付きリストの場合、名前を使用してアクセスすることもできます。
上記の例のリストを使用し続けます-
# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
list("green",12.3))
# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")
# Access the first element of the list.
print(list_data[1])
# Access the thrid element. As it is also a list, all its elements will be printed.
print(list_data[3])
# Access the list element using the name of the element.
print(list_data$A_Matrix)上記のコードを実行すると、次の結果が生成されます-
$`1st_Quarter`
[1] "Jan" "Feb" "Mar"
$A_Inner_list
$A_Inner_list[[green"
$A_Inner_list[[Manipulating List Elements
We can add, delete and update list elements as shown below. We can add and delete elements only at the end of a list. But we can update any element.
[source,prettyprint,notranslate]＃ベクトル、マトリックス、リストを含むリストを作成します。 list_data ←list（c（ "Jan"、 "Feb"、 "Mar"）、matrix（c（3,9,5,1、-2,8）、nrow = 2）、list（ "green"、12.3 ））
＃リスト内の要素に名前を付けます。 names（list_data）←c（ "1st Quarter"、 "A_Matrix"、 "A内部リスト"）
＃リストの最後に要素を追加します。 list_data [4] ←"新しい要素" print（list_data [4]）
＃最後の要素を削除します。 list_data [4] ←NULL
＃4番目の要素を印刷します。 print（list_data [4]）
＃3番目の要素を更新します。 list_data [3] ←"更新された要素" print（list_data [3]）
When we execute the above code, it produces the following result −
[source,result,notranslate][[新しい要素]
$ <NA> NULL
$ 内部リスト [1] "updated element"
=== Merging Lists
You can merge many lists into one list by placing all the lists inside one list() function.
[source,prettyprint,notranslate]＃2つのリストを作成します。 list1 ←list（1,2,3）list2 ←list（ "Sun"、 "Mon"、 "Tue"）
＃2つのリストをマージします。 merged.list ←c（list1、list2）
＃結合リストを印刷します。 print（merged.list）
When we execute the above code, it produces the following result −
[source,result,notranslate][[太陽"
[[月]
[[火]
Converting List to Vector
A list can be converted to a vector so that the elements of the vector can be used for further manipulation. All the arithmetic operations on vectors can be applied after the list is converted into vectors. To do this conversion, we use the unlist() function. It takes the list as input and produces a vector.
＃リストを作成します。 list1 <-list（1：5）print（list1）
list2 <-list（10:14）print（list2）
＃リストをベクトルに変換します。 v1 <-unlist（list1）v2 <-unlist（list2）
print（v1）print（v2）
＃次にベクターの結果を追加<-v1 + v2 print（result）When we execute the above code, it produces the following result −
[[R-行列
行列は、要素が2次元の長方形のレイアウトで配置されているRオブジェクトです。 それらには、同じ原子型の要素が含まれます。 文字のみまたは論理値のみを含むマトリックスを作成できますが、あまり役に立ちません。 数学的計算に使用される数値要素を含む行列を使用します。
マトリックスは、* matrix（）*関数を使用して作成されます。
構文
Rで行列を作成するための基本的な構文は次のとおりです-
matrix(data, nrow, ncol, byrow, dimnames)以下は、使用されるパラメータの説明です-
- data は、行列のデータ要素になる入力ベクトルです。
- nrow は、作成される行の数です。
- ncol は、作成される列の数です。
- byrow は論理的な手がかりです。 TRUEの場合、入力ベクトル要素は行ごとに配置されます。
- dimname は、行と列に割り当てられた名前です。
例
入力として数値のベクトルを取る行列を作成します。
# Elements are arranged sequentially by row.
M <- matrix(c(3:14), nrow = 4, byrow = TRUE)
print(M)
# Elements are arranged sequentially by column.
N <- matrix(c(3:14), nrow = 4, byrow = FALSE)
print(N)
# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")
P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
print(P)上記のコードを実行すると、次の結果が生成されます-
[,1] [,2] [,3]
[1,] 3 4 5
[2,] 6 7 8
[3,] 9 10 11
[4,] 12 13 14
[,1] [,2] [,3]
[1,] 3 7 11
[2,] 4 8 12
[3,] 5 9 13
[4,] 6 10 14
col1 col2 col3
row1 3 4 5
row2 6 7 8
row3 9 10 11
row4 12 13 14マトリックスの要素へのアクセス
行列の要素には、要素の列と行のインデックスを使用してアクセスできます。 以下の特定の要素を見つけるために、上の行列Pを考慮します。
# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")
# Create the matrix.
P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
# Access the element at 3rd column and 1st row.
print(P[1,3])
# Access the element at 2nd column and 4th row.
print(P[4,2])
# Access only the 2nd row.
print(P[2,])
# Access only the 3rd column.
print(P[,3])上記のコードを実行すると、次の結果が生成されます-
[1] 5
[1] 13
col1 col2 col3
6 7 8
row1 row2 row3 row4
5 8 11 14行列計算
R演算子を使用して、行列に対してさまざまな数学演算が実行されます。 演算の結果も行列です。
次元（行と列の数）は、操作に関係する行列で同じでなければなりません。
行列の加算と減算
# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)
matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)
# Add the matrices.
result <- matrix1 + matrix2
cat("Result of addition","\n")
print(result)
# Subtract the matrices
result <- matrix1 - matrix2
cat("Result of subtraction","\n")
print(result)上記のコードを実行すると、次の結果が生成されます-
[,1] [,2] [,3]
[1,] 3 -1 2
[2,] 9 4 6
[,1] [,2] [,3]
[1,] 5 0 3
[2,] 2 9 4
Result of addition
[,1] [,2] [,3]
[1,] 8 -1 5
[2,] 11 13 10
Result of subtraction
[,1] [,2] [,3]
[1,] -2 -1 -1
[2,] 7 -5 2行列の乗算と除算
# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)
matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)
# Multiply the matrices.
result <- matrix1 * matrix2
cat("Result of multiplication","\n")
print(result)
# Divide the matrices
result <- matrix1/matrix2
cat("Result of division","\n")
print(result)上記のコードを実行すると、次の結果が生成されます-
[,1] [,2] [,3]
[1,] 3 -1 2
[2,] 9 4 6
[,1] [,2] [,3]
[1,] 5 0 3
[2,] 2 9 4
Result of multiplication
[,1] [,2] [,3]
[1,] 15 0 6
[2,] 18 36 24
Result of division
[,1] [,2] [,3]
[1,] 0.6 -Inf 0.6666667
[2,] 4.5 0.4444444 1.5000000R-配列
配列は、3次元以上でデータを保存できるRデータオブジェクトです。 たとえば-次元の配列（2、3、4）を作成すると、それぞれ2行3列の4つの長方形行列が作成されます。 配列はデータ型のみを保存できます。
配列は* array（）関数を使用して作成されます。 入力としてベクトルを受け取り、 *dim パラメーターの値を使用して配列を作成します。
例
次の例では、それぞれ3行3列の2つの3x3行列の配列を作成します。
# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2))
print(result)上記のコードを実行すると、次の結果が生成されます-
, , 1
[,1] [,2] [,3]
[1,] 5 10 13
[2,] 9 11 14
[3,] 3 12 15
, , 2
[,1] [,2] [,3]
[1,] 5 10 13
[2,] 9 11 14
[3,] 3 12 15列と行の命名
*dimnames* パラメーターを使用して、配列内の行、列、および行列に名前を付けることができます。# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")
# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,column.names,
matrix.names))
print(result)上記のコードを実行すると、次の結果が生成されます-
, , Matrix1
COL1 COL2 COL3
ROW1 5 10 13
ROW2 9 11 14
ROW3 3 12 15
, , Matrix2
COL1 COL2 COL3
ROW1 5 10 13
ROW2 9 11 14
ROW3 3 12 15配列要素へのアクセス
# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")
# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,
column.names, matrix.names))
# Print the third row of the second matrix of the array.
print(result[3,,2])
# Print the element in the 1st row and 3rd column of the 1st matrix.
print(result[1,3,1])
# Print the 2nd Matrix.
print(result[,,2])上記のコードを実行すると、次の結果が生成されます-
COL1 COL2 COL3
3 12 15
[1] 13
COL1 COL2 COL3
ROW1 5 10 13
ROW2 9 11 14
ROW3 3 12 15配列要素の操作
配列は複数の次元のマトリックスで構成されているため、配列の要素に対する操作は、マトリックスの要素にアクセスすることで実行されます。
# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
# Take these vectors as input to the array.
array1 <- array(c(vector1,vector2),dim = c(3,3,2))
# Create two vectors of different lengths.
vector3 <- c(9,1,0)
vector4 <- c(6,0,11,3,14,1,2,6,9)
array2 <- array(c(vector1,vector2),dim = c(3,3,2))
# create matrices from these arrays.
matrix1 <- array1[,,2]
matrix2 <- array2[,,2]
# Add the matrices.
result <- matrix1+matrix2
print(result)上記のコードを実行すると、次の結果が生成されます-
[,1] [,2] [,3]
[1,] 10 20 26
[2,] 18 22 28
[3,] 6 24 30配列要素全体の計算
- apply（）*関数を使用して、配列内の要素間で計算を行うことができます。
構文
apply(x, margin, fun)以下は、使用されるパラメータの説明です-
- x は配列です。
- margin は、使用されるデータセットの名前です。
- fun は、配列の要素全体に適用される関数です。
例
以下のapply（）関数を使用して、すべてのマトリックスにわたる配列の行の要素の合計を計算します。
# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
# Take these vectors as input to the array.
new.array <- array(c(vector1,vector2),dim = c(3,3,2))
print(new.array)
# Use apply to calculate the sum of the rows across all the matrices.
result <- apply(new.array, c(1), sum)
print(result)上記のコードを実行すると、次の結果が生成されます-
, , 1
[,1] [,2] [,3]
[1,] 5 10 13
[2,] 9 11 14
[3,] 3 12 15
, , 2
[,1] [,2] [,3]
[1,] 5 10 13
[2,] 9 11 14
[3,] 3 12 15
[1] 56 68 60R-要因
ファクターは、データを分類してレベルとして保存するために使用されるデータオブジェクトです。 文字列と整数の両方を保存できます。 これらは、限られた数の一意の値を持つ列で役立ちます。 「男性、女性」、True、Falseなど。 統計モデリングのデータ分析に役立ちます。
因子は、ベクトルを入力として* factor（）*関数を使用して作成されます。
例
# Create a vector as input.
data <- c("East","West","East","North","North","East","West","West","West","East","North")
print(data)
print(is.factor(data))
# Apply the factor function.
factor_data <- factor(data)
print(factor_data)
print(is.factor(factor_data))上記のコードを実行すると、次の結果が生成されます-
[1] "East" "West" "East" "North" "North" "East" "West" "West" "West" "East" "North"
[1] FALSE
[1] East West East North North East West West West East North
Levels: East North West
[1] TRUEデータフレームの要因
テキストデータの列を持つデータフレームを作成すると、Rはテキスト列をカテゴリカルデータとして扱い、その列にファクターを作成します。
# Create the vectors for data frame.
height <- c(132,151,162,139,166,147,122)
weight <- c(48,49,66,53,67,52,40)
gender <- c("male","male","female","female","male","female","male")
# Create the data frame.
input_data <- data.frame(height,weight,gender)
print(input_data)
# Test if the gender column is a factor.
print(is.factor(input_data$gender))
# Print the gender column so see the levels.
print(input_data$gender)上記のコードを実行すると、次の結果が生成されます-
height weight gender
1 132 48 male
2 151 49 male
3 162 66 female
4 139 53 female
5 166 67 male
6 147 52 female
7 122 40 male
[1] TRUE
[1] male male female female male female male
Levels: female maleレベルの順序を変更する
因子内のレベルの順序は、新しいレベルの順序で因子関数を再度適用することにより変更できます。
data <- c("East","West","East","North","North","East","West",
"West","West","East","North")
# Create the factors
factor_data <- factor(data)
print(factor_data)
# Apply the factor function with required order of the level.
new_order_data <- factor(factor_data,levels = c("East","West","North"))
print(new_order_data)上記のコードを実行すると、次の結果が生成されます-
[1] East West East North North East West West West East North
Levels: East North West
[1] East West East North North East West West West East North
Levels: East West North因子レベルの生成
- gl（）*関数を使用して、因子レベルを生成できます。 入力として2つの整数を取り、それはレベルの数と各レベルの回数を示します。
構文
gl(n, k, labels)以下は、使用されるパラメータの説明です-
- n はレベル数を示す整数です。
- k は、レプリケーションの数を示す整数です。
- labels は、結果の因子レベルのラベルのベクトルです。
例
v <- gl(3, 4, labels = c("Tampa", "Seattle","Boston"))
print(v)上記のコードを実行すると、次の結果が生成されます-
Tampa Tampa Tampa Tampa Seattle Seattle Seattle Seattle Boston
[10] Boston Boston Boston
Levels: Tampa Seattle BostonR-データフレーム
データフレームはテーブルまたは2次元配列のような構造で、各列には1つの変数の値が含まれ、各行には各列の値のセットが1つ含まれます。
以下は、データフレームの特性です。
- 列名は空ではないはずです。
- 行名は一意である必要があります。
- データフレームに格納されるデータは、数値、ファクタ、または文字タイプです。
- 各列には同じ数のデータ項目が含まれている必要があります。
データフレームの作成
# Create the data frame.
emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),
start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
"2015-03-27")),
stringsAsFactors = FALSE
)
# Print the data frame.
print(emp.data)上記のコードを実行すると、次の結果が生成されます-
emp_id emp_name salary start_date
1 1 Rick 623.30 2012-01-01
2 2 Dan 515.20 2013-09-23
3 3 Michelle 611.00 2014-11-15
4 4 Ryan 729.00 2014-05-11
5 5 Gary 843.25 2015-03-27データフレームの構造を取得する
データフレームの構造は、* str（）*関数を使用して確認できます。
# Create the data frame.
emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),
start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
"2015-03-27")),
stringsAsFactors = FALSE
)
# Get the structure of the data frame.
str(emp.data)上記のコードを実行すると、次の結果が生成されます-
'data.frame': 5 obs. of 4 variables:
$ emp_id : int 1 2 3 4 5
$ emp_name : chr "Rick" "Dan" "Michelle" "Ryan" ...
$ salary : num 623 515 611 729 843
$ start_date: Date, format: "2012-01-01" "2013-09-23" "2014-11-15" "2014-05-11" ...データフレームのデータの概要
統計の概要とデータの性質は、* summary（）*関数を適用することで取得できます。
# Create the data frame.
emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),
start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
"2015-03-27")),
stringsAsFactors = FALSE
)
# Print the summary.
print(summary(emp.data))上記のコードを実行すると、次の結果が生成されます-
emp_id emp_name salary start_date
Min. :1 Length:5 Min. :515.2 Min. :2012-01-01
1st Qu.:2 Class :character 1st Qu.:611.0 1st Qu.:2013-09-23
Median :3 Mode :character Median :623.3 Median :2014-05-11
Mean :3 Mean :664.4 Mean :2014-01-14
3rd Qu.:4 3rd Qu.:729.0 3rd Qu.:2014-11-15
Max. :5 Max. :843.2 Max. :2015-03-27データフレームからデータを抽出する
列名を使用してデータフレームから特定の列を抽出します。
# Create the data frame.
emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),
start_date = as.Date(c("2012-01-01","2013-09-23","2014-11-15","2014-05-11",
"2015-03-27")),
stringsAsFactors = FALSE
)
# Extract Specific columns.
result <- data.frame(emp.data$emp_name,emp.data$salary)
print(result)上記のコードを実行すると、次の結果が生成されます-
emp.data.emp_name emp.data.salary
1 Rick 623.30
2 Dan 515.20
3 Michelle 611.00
4 Ryan 729.00
5 Gary 843.25最初の2行を抽出してから、すべての列を抽出します
# Create the data frame.
emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),
start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
"2015-03-27")),
stringsAsFactors = FALSE
)
# Extract first two rows.
result <- emp.data[1:2,]
print(result)上記のコードを実行すると、次の結果が生成されます-
emp_id emp_name salary start_date
1 1 Rick 623.3 2012-01-01
2 2 Dan 515.2 2013-09-232 ^ nd ^および4 ^ th ^列で3 ^ rd ^および5 ^ th ^行を抽出します
# Create the data frame.
emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),
start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
"2015-03-27")),
stringsAsFactors = FALSE
)
# Extract 3rd and 5th row with 2nd and 4th column.
result <- emp.data[c(3,5),c(2,4)]
print(result)上記のコードを実行すると、次の結果が生成されます-
emp_name start_date
3 Michelle 2014-11-15
5 Gary 2015-03-27データフレームを展開
データフレームは、列と行を追加することで拡張できます。
列を追加
新しい列名を使用して列ベクトルを追加するだけです。
# Create the data frame.
emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),
start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
"2015-03-27")),
stringsAsFactors = FALSE
)
# Add the "dept" coulmn.
emp.data$dept <- c("IT","Operations","IT","HR","Finance")
v <- emp.data
print(v)上記のコードを実行すると、次の結果が生成されます-
emp_id emp_name salary start_date dept
1 1 Rick 623.30 2012-01-01 IT
2 2 Dan 515.20 2013-09-23 Operations
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 5 Gary 843.25 2015-03-27 Finance行を追加する
既存のデータフレームに永続的に行を追加するには、既存のデータフレームと同じ構造で新しい行を取り込み、* rbind（）*関数を使用する必要があります。
以下の例では、新しい行を含むデータフレームを作成し、既存のデータフレームとマージして最終的なデータフレームを作成します。
# Create the first data frame.
emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),
start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
"2015-03-27")),
dept = c("IT","Operations","IT","HR","Finance"),
stringsAsFactors = FALSE
)
# Create the second data frame
emp.newdata <- data.frame(
emp_id = c (6:8),
emp_name = c("Rasmi","Pranab","Tusar"),
salary = c(578.0,722.5,632.8),
start_date = as.Date(c("2013-05-21","2013-07-30","2014-06-17")),
dept = c("IT","Operations","Fianance"),
stringsAsFactors = FALSE
)
# Bind the two data frames.
emp.finaldata <- rbind(emp.data,emp.newdata)
print(emp.finaldata)上記のコードを実行すると、次の結果が生成されます-
emp_id emp_name salary start_date dept
1 1 Rick 623.30 2012-01-01 IT
2 2 Dan 515.20 2013-09-23 Operations
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 5 Gary 843.25 2015-03-27 Finance
6 6 Rasmi 578.00 2013-05-21 IT
7 7 Pranab 722.50 2013-07-30 Operations
8 8 Tusar 632.80 2014-06-17 FiananceR-パッケージ
Rパッケージは、R関数、コンパイルされたコード、およびサンプルデータのコレクションです。 これらは、R環境の "library" というディレクトリに保存されます。 デフォルトでは、Rはインストール中に一連のパッケージをインストールします。 いくつかの特定の目的で必要になったときに、後でパッケージが追加されます。 Rコンソールを起動すると、デフォルトではデフォルトのパッケージのみが利用可能です。 既にインストールされている他のパッケージは、それらを使用するRプログラムで使用するために明示的にロードする必要があります。
R言語で利用可能なすべてのパッケージは、https://cran.r-project.org/web/packages/available_packages_by_namel [R Packages。]にリストされています。
以下は、Rパッケージをチェック、検証、使用するために使用するコマンドのリストです。
利用可能なRパッケージを確認する
Rパッケージを含むライブラリの場所を取得する
.libPaths()上記のコードを実行すると、次の結果が生成されます。 PCのローカル設定によって異なる場合があります。
[2] "C:/Program Files/R/R-3.2.2/library"インストールされているすべてのパッケージのリストを取得します
library()上記のコードを実行すると、次の結果が生成されます。 PCのローカル設定によって異なる場合があります。
Packages in library ‘C:/Program Files/R/R-3.2.2/library’:
base The R Base Package
boot Bootstrap Functions (Originally by Angelo Canty
for S)
class Functions for Classification
cluster "Finding Groups in Data": Cluster Analysis
Extended Rousseeuw et al.
codetools Code Analysis Tools for R
compiler The R Compiler Package
datasets The R Datasets Package
foreign Read Data Stored by 'Minitab', 'S', 'SAS',
'SPSS', 'Stata', 'Systat', 'Weka', 'dBase', ...
graphics The R Graphics Package
grDevices The R Graphics Devices and Support for Colours
and Fonts
grid The Grid Graphics Package
KernSmooth Functions for Kernel Smoothing Supporting Wand
& Jones (1995)
lattice Trellis Graphics for R
MASS Support Functions and Datasets for Venables and
Ripley's MASS
Matrix Sparse and Dense Matrix Classes and Methods
methods Formal Methods and Classes
mgcv Mixed GAM Computation Vehicle with GCV/AIC/REML
Smoothness Estimation
nlme Linear and Nonlinear Mixed Effects Models
nnet Feed-Forward Neural Networks and Multinomial
Log-Linear Models
parallel Support for Parallel computation in R
rpart Recursive Partitioning and Regression Trees
spatial Functions for Kriging and Point Pattern
Analysis
splines Regression Spline Functions and Classes
stats The R Stats Package
stats4 Statistical Functions using S4 Classes
survival Survival Analysis
tcltk Tcl/Tk Interface
tools Tools for Package Development
utils The R Utils PackageR環境に現在ロードされているすべてのパッケージを取得します
search()上記のコードを実行すると、次の結果が生成されます。 PCのローカル設定によって異なる場合があります。
[1] ".GlobalEnv" "package:stats" "package:graphics"
[4] "package:grDevices" "package:utils" "package:datasets"
[7] "package:methods" "Autoloads" "package:base"新しいパッケージをインストールする
新しいRパッケージを追加するには2つの方法があります。 1つはCRANディレクトリから直接インストールする方法、もう1つはローカルシステムにパッケージをダウンロードして手動でインストールする方法です。
CRANから直接インストールする
次のコマンドは、CRAN Webページからパッケージを直接取得し、R環境にパッケージをインストールします。 最も近いミラーを選択するように求められる場合があります。 あなたの場所に適したものを選択してください。
install.packages("Package Name")
# Install the package named "XML".
install.packages("XML")パッケージを手動でインストールする
リンクhttps://cran.r-project.org/web/packages/available_packages_by_namel[R Packages]にアクセスして、必要なパッケージをダウンロードします。 パッケージを .zip ファイルとしてローカルシステムの適切な場所に保存します。
これで、次のコマンドを実行して、このパッケージをR環境にインストールできます。
install.packages(file_name_with_path, repos = NULL, type = "source")
# Install the package named "XML"
install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")パッケージをライブラリにロード
パッケージをコードで使用する前に、現在のR環境にロードする必要があります。 また、既にインストールされているが現在の環境では利用できないパッケージをロードする必要があります。
パッケージは、次のコマンドを使用してロードされます-
library("package Name", lib.loc = "path to library")
# Load the package named "XML"
install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")R-データの形状変更
Rでのデータの再形成とは、データを行と列に編成する方法を変更することです。 Rでのデータ処理のほとんどは、入力データをデータフレームとして取得することによって行われます。 データフレームの行と列からデータを抽出するのは簡単ですが、受信した形式とは異なる形式のデータフレームが必要な場合があります。 Rには、データフレーム内で行を列に、またはその逆に分割、マージ、および変更するための多くの機能があります。
データフレーム内の列と行の結合
- cbind（）*関数を使用して、複数のベクトルを結合してデータフレームを作成できます。 また、 rbind（）*関数を使用して2つのデータフレームをマージできます。
# Create vector objects.
city <- c("Tampa","Seattle","Hartford","Denver")
state <- c("FL","WA","CT","CO")
zipcode <- c(33602,98104,06161,80294)
# Combine above three vectors into one data frame.
addresses <- cbind(city,state,zipcode)
# Print a header.
cat("# # # # The First data frame\n")
# Print the data frame.
print(addresses)
# Create another data frame with similar columns
new.address <- data.frame(
city = c("Lowry","Charlotte"),
state = c("CO","FL"),
zipcode = c("80230","33949"),
stringsAsFactors = FALSE
)
# Print a header.
cat("# # # The Second data frame\n")
# Print the data frame.
print(new.address)
# Combine rows form both the data frames.
all.addresses <- rbind(addresses,new.address)
# Print a header.
cat("# # # The combined data frame\n")
# Print the result.
print(all.addresses)上記のコードを実行すると、次の結果が生成されます-
# # # # The First data frame
city state zipcode
[1,] "Tampa" "FL" "33602"
[2,] "Seattle" "WA" "98104"
[3,] "Hartford" "CT" "6161"
[4,] "Denver" "CO" "80294"
# # # The Second data frame
city state zipcode
1 Lowry CO 80230
2 Charlotte FL 33949
# # # The combined data frame
city state zipcode
1 Tampa FL 33602
2 Seattle WA 98104
3 Hartford CT 6161
4 Denver CO 80294
5 Lowry CO 80230
6 Charlotte FL 33949データフレームの結合
- merge（）*関数を使用して、2つのデータフレームをマージできます。 データフレームには、マージが発生する列名が同じである必要があります。
以下の例では、ライブラリ名「MASS」で利用可能なピマインド女性の糖尿病に関するデータセットを検討します。 血圧（ "bp"）とボディマスインデックス（ "bmi"）の値に基づいて2つのデータセットをマージします。 マージのためにこれらの2つの列を選択すると、これら2つの変数の値が両方のデータセットで一致するレコードが結合されて、単一のデータフレームが形成されます。
library(MASS)
merged.Pima <- merge(x = Pima.te, y = Pima.tr,
by.x = c("bp", "bmi"),
by.y = c("bp", "bmi")
)
print(merged.Pima)
nrow(merged.Pima)上記のコードを実行すると、次の結果が生成されます-
bp bmi npreg.x glu.x skin.x ped.x age.x type.x npreg.y glu.y skin.y ped.y
1 60 33.8 1 117 23 0.466 27 No 2 125 20 0.088
2 64 29.7 2 75 24 0.370 33 No 2 100 23 0.368
3 64 31.2 5 189 33 0.583 29 Yes 3 158 13 0.295
4 64 33.2 4 117 27 0.230 24 No 1 96 27 0.289
5 66 38.1 3 115 39 0.150 28 No 1 114 36 0.289
6 68 38.5 2 100 25 0.324 26 No 7 129 49 0.439
7 70 27.4 1 116 28 0.204 21 No 0 124 20 0.254
8 70 33.1 4 91 32 0.446 22 No 9 123 44 0.374
9 70 35.4 9 124 33 0.282 34 No 6 134 23 0.542
10 72 25.6 1 157 21 0.123 24 No 4 99 17 0.294
11 72 37.7 5 95 33 0.370 27 No 6 103 32 0.324
12 74 25.9 9 134 33 0.460 81 No 8 126 38 0.162
13 74 25.9 1 95 21 0.673 36 No 8 126 38 0.162
14 78 27.6 5 88 30 0.258 37 No 6 125 31 0.565
15 78 27.6 10 122 31 0.512 45 No 6 125 31 0.565
16 78 39.4 2 112 50 0.175 24 No 4 112 40 0.236
17 88 34.5 1 117 24 0.403 40 Yes 4 127 11 0.598
age.y type.y
1 31 No
2 21 No
3 24 No
4 21 No
5 21 No
6 43 Yes
7 36 Yes
8 40 No
9 29 Yes
10 28 No
11 55 No
12 39 No
13 39 No
14 49 Yes
15 49 Yes
16 38 No
17 28 No
[1] 17溶解と鋳造
Rプログラミングの最も興味深い側面の1つは、データの形状を複数のステップで変更して、目的の形状にすることです。 これを行うために使用される関数は、* melt（）および cast（）*と呼ばれます。
「MASS」というライブラリに存在する「ships」というデータセットを検討します。
library(MASS)
print(ships)上記のコードを実行すると、次の結果が生成されます-
type year period service incidents
1 A 60 60 127 0
2 A 60 75 63 0
3 A 65 60 1095 3
4 A 65 75 1095 4
5 A 70 60 1512 6
.............
.............
8 A 75 75 2244 11
9 B 60 60 44882 39
10 B 60 75 17176 29
11 B 65 60 28609 58
............
............
17 C 60 60 1179 1
18 C 60 75 552 1
19 C 65 60 781 0
............
............データを溶かす
次に、データを融解して整理し、タイプと年以外のすべての列を複数の行に変換します。
molten.ships <- melt(ships, id = c("type","year"))
print(molten.ships)上記のコードを実行すると、次の結果が生成されます-
type year variable value
1 A 60 period 60
2 A 60 period 75
3 A 65 period 60
4 A 65 period 75
............
............
9 B 60 period 60
10 B 60 period 75
11 B 65 period 60
12 B 65 period 75
13 B 70 period 60
...........
...........
41 A 60 service 127
42 A 60 service 63
43 A 65 service 1095
...........
...........
70 D 70 service 1208
71 D 75 service 0
72 D 75 service 2051
73 E 60 service 45
74 E 60 service 0
75 E 65 service 789
...........
...........
101 C 70 incidents 6
102 C 70 incidents 2
103 C 75 incidents 0
104 C 75 incidents 1
105 D 60 incidents 0
106 D 60 incidents 0
...........
...........溶融データのキャスト
溶融データを新しい形式にキャストして、各年の各タイプの船舶の集合体を作成できます。 * cast（）*関数を使用して行われます。
recasted.ship <- cast(molten.ships, type+year~variable,sum)
print(recasted.ship)上記のコードを実行すると、次の結果が生成されます-
type year period service incidents
1 A 60 135 190 0
2 A 65 135 2190 7
3 A 70 135 4865 24
4 A 75 135 2244 11
5 B 60 135 62058 68
6 B 65 135 48979 111
7 B 70 135 20163 56
8 B 75 135 7117 18
9 C 60 135 1731 2
10 C 65 135 1457 1
11 C 70 135 2731 8
12 C 75 135 274 1
13 D 60 135 356 0
14 D 65 135 480 0
15 D 70 135 1557 13
16 D 75 135 2051 4
17 E 60 135 45 0
18 E 65 135 1226 14
19 E 70 135 3318 17
20 E 75 135 542 1R-CSVファイル
Rでは、R環境の外部に保存されているファイルからデータを読み取ることができます。 また、オペレーティングシステムによって保存およびアクセスされるファイルにデータを書き込むこともできます。 Rは、csv、excel、xmlなどのさまざまなファイル形式を読み書きできます。
この章では、csvファイルからデータを読み取り、csvファイルにデータを書き込む方法を学習します。 Rが読み取れるように、ファイルは現在の作業ディレクトリに存在する必要があります。 もちろん、独自のディレクトリを設定し、そこからファイルを読み取ることもできます。
作業ディレクトリの取得と設定
- getwd（）*関数を使用して、Rワークスペースが指しているディレクトリを確認できます。 setwd（）関数を使用して、新しい作業ディレクトリを設定することもできます。
# Get and print current working directory.
print(getwd())
# Set current working directory.
setwd("/web/com")
# Get and print current working directory.
print(getwd())上記のコードを実行すると、次の結果が生成されます-
[1] "/web/com/1441086124_2016"
[1] "/web/com"この結果は、使用しているOSと現在のディレクトリによって異なります。
CSVファイルとして入力
csvファイルは、列の値がコンマで区切られたテキストファイルです。 input.csv という名前のファイルに存在する次のデータを考えてみましょう。
このデータをコピーして貼り付けることにより、Windowsのメモ帳を使用してこのファイルを作成できます。 メモ帳の[すべてのファイルとして保存（。）]オプションを使用して、ファイルを input.csv として保存します。
id,name,salary,start_date,dept
1,Rick,623.3,2012-01-01,IT
2,Dan,515.2,2013-09-23,Operations
3,Michelle,611,2014-11-15,IT
4,Ryan,729,2014-05-11,HR
5,Gary,843.25,2015-03-27,Finance
6,Nina,578,2013-05-21,IT
7,Simon,632.8,2013-07-30,Operations
8,Guru,722.5,2014-06-17,FinanceCSVファイルの読み取り
以下は、現在の作業ディレクトリで使用可能なCSVファイルを読み取る* read.csv（）*関数の簡単な例です-
data <- read.csv("input.csv")
print(data)上記のコードを実行すると、次の結果が生成されます-
id, name, salary, start_date, dept
1 1 Rick 623.30 2012-01-01 IT
2 2 Dan 515.20 2013-09-23 Operations
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 NA Gary 843.25 2015-03-27 Finance
6 6 Nina 578.00 2013-05-21 IT
7 7 Simon 632.80 2013-07-30 Operations
8 8 Guru 722.50 2014-06-17 FinanceCSVファイルの分析
デフォルトでは、* read.csv（）*関数は出力をデータフレームとして提供します。 これは次のように簡単に確認できます。 また、列と行の数を確認できます。
data <- read.csv("input.csv")
print(is.data.frame(data))
print(ncol(data))
print(nrow(data))上記のコードを実行すると、次の結果が生成されます-
[1] TRUE
[1] 5
[1] 8データフレームのデータを読み取った後、次のセクションで説明するように、データフレームに適用可能なすべての機能を適用できます。
最高給与を取得
# Create a data frame.
data <- read.csv("input.csv")
# Get the max salary from data frame.
sal <- max(data$salary)
print(sal)上記のコードを実行すると、次の結果が生成されます-
[1] 843.25最高給与の人の詳細を取得する
SQLのwhere句に似た特定のフィルター基準を満たす行をフェッチできます。
# Create a data frame.
data <- read.csv("input.csv")
# Get the max salary from data frame.
sal <- max(data$salary)
# Get the person detail having max salary.
retval <- subset(data, salary == max(salary))
print(retval)上記のコードを実行すると、次の結果が生成されます-
id name salary start_date dept
5 NA Gary 843.25 2015-03-27 FinanceIT部門で働くすべての人々を獲得する
# Create a data frame.
data <- read.csv("input.csv")
retval <- subset( data, dept == "IT")
print(retval)上記のコードを実行すると、次の結果が生成されます-
id name salary start_date dept
1 1 Rick 623.3 2012-01-01 IT
3 3 Michelle 611.0 2014-11-15 IT
6 6 Nina 578.0 2013-05-21 IT給与が600を超えるIT部門の人を取得する
# Create a data frame.
data <- read.csv("input.csv")
info <- subset(data, salary > 600 & dept == "IT")
print(info)上記のコードを実行すると、次の結果が生成されます-
id name salary start_date dept
1 1 Rick 623.3 2012-01-01 IT
3 3 Michelle 611.0 2014-11-15 IT2014年以降に参加した人を取得する
# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))
print(retval)上記のコードを実行すると、次の結果が生成されます-
id name salary start_date dept
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 NA Gary 843.25 2015-03-27 Finance
8 8 Guru 722.50 2014-06-17 FinanceCSVファイルへの書き込み
Rは、既存のデータフレームからCSVファイルを作成できます。 * write.csv（）*関数を使用して、csvファイルを作成します。 このファイルは作業ディレクトリに作成されます。
# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))
# Write filtered data into a new file.
write.csv(retval,"output.csv")
newdata <- read.csv("output.csv")
print(newdata)上記のコードを実行すると、次の結果が生成されます-
X id name salary start_date dept
1 3 3 Michelle 611.00 2014-11-15 IT
2 4 4 Ryan 729.00 2014-05-11 HR
3 5 NA Gary 843.25 2015-03-27 Finance
4 8 8 Guru 722.50 2014-06-17 Financeここで、列Xはデータセットnewperに由来します。 これは、ファイルの書き込み中に追加のパラメーターを使用して削除できます。
# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))
# Write filtered data into a new file.
write.csv(retval,"output.csv", row.names = FALSE)
newdata <- read.csv("output.csv")
print(newdata)上記のコードを実行すると、次の結果が生成されます-
id name salary start_date dept
1 3 Michelle 611.00 2014-11-15 IT
2 4 Ryan 729.00 2014-05-11 HR
3 NA Gary 843.25 2015-03-27 Finance
4 8 Guru 722.50 2014-06-17 FinanceR-Excelファイル
Microsoft Excelは、最も広く使用されているスプレッドシートプログラムで、データを.xlsまたは.xlsx形式で保存します。 Rは、Excel固有のパッケージを使用してこれらのファイルから直接読み取ることができます。 そのようなパッケージはほとんどありません-XLConnect、xlsx、gdataなど。 xlsxパッケージを使用します。 Rは、このパッケージを使用してExcelファイルに書き込むこともできます。
xlsxパッケージをインストールする
Rコンソールで次のコマンドを使用して、「xlsx」パッケージをインストールできます。 このパッケージが依存するいくつかの追加パッケージをインストールするように求められる場合があります。 必要なパッケージ名を指定して同じコマンドを実行し、追加のパッケージをインストールします。
install.packages("xlsx")「xlsx」パッケージの確認とロード
次のコマンドを使用して、「xlsx」パッケージを確認およびロードします。
# Verify the package is installed.
any(grepl("xlsx",installed.packages()))
# Load the library into R workspace.
library("xlsx")スクリプトを実行すると、次の出力が得られます。
[1] TRUE
Loading required package: rJava
Loading required package: methods
Loading required package: xlsxjarsxlsxファイルとして入力
Microsoft Excelを開きます。 次のデータをコピーして、sheet1という名前のワークシートに貼り付けます。
id name salary start_date dept
1 Rick 623.3 1/1/2012 IT
2 Dan 515.2 9/23/2013 Operations
3 Michelle 611 11/15/2014 IT
4 Ryan 729 5/11/2014 HR
5 Gary 43.25 3/27/2015 Finance
6 Nina 578 5/21/2013 IT
7 Simon 632.8 7/30/2013 Operations
8 Guru 722.5 6/17/2014 Financeまた、次のデータをコピーして別のワークシートに貼り付け、このワークシートの名前を「city」に変更します。
name city
Rick Seattle
Dan Tampa
Michelle Chicago
Ryan Seattle
Gary Houston
Nina Boston
Simon Mumbai
Guru DallasExcelファイルを「input.xlsx」として保存します。 Rワークスペースの現在の作業ディレクトリに保存する必要があります。
Excelファイルの読み取り
input.xlsxは、以下に示すように* read.xlsx（）*関数を使用して読み取られます。 結果は、データフレームとしてR環境に保存されます。
# Read the first worksheet in the file input.xlsx.
data <- read.xlsx("input.xlsx", sheetIndex = 1)
print(data)上記のコードを実行すると、次の結果が生成されます-
id, name, salary, start_date, dept
1 1 Rick 623.30 2012-01-01 IT
2 2 Dan 515.20 2013-09-23 Operations
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 NA Gary 843.25 2015-03-27 Finance
6 6 Nina 578.00 2013-05-21 IT
7 7 Simon 632.80 2013-07-30 Operations
8 8 Guru 722.50 2014-06-17 FinanceR-バイナリファイル
バイナリファイルは、ビットとバイトの形式でのみ格納された情報を含むファイルです（0と1）。 その中のバイトは、他の多くの印刷不可能な文字を含む文字や記号に変換されるため、人間が読むことはできません。 テキストエディターを使用してバイナリファイルを読み取ろうとすると、Øやðなどの文字が表示されます。
バイナリファイルを使用するには、特定のプログラムで読み取る必要があります。 たとえば、Microsoft Wordプログラムのバイナリファイルは、Wordプログラムでのみ人間が読み取れる形式に読み取ることができます。 これは、人間が読めるテキストの他に、文字やページ番号などの書式設定など、英数字とともに保存される情報がはるかに多いことを示しています。 最後に、バイナリファイルは連続したバイトシーケンスです。 テキストファイルに表示される改行は、最初の行を次の行に結合する文字です。
他のプログラムによって生成されたデータは、Rによってバイナリファイルとして処理される必要がある場合があります。 また、Rは他のプログラムと共有できるバイナリファイルを作成するために必要です。
Rには、バイナリファイルを作成および読み取るための2つの関数* WriteBin（）および readBin（）*があります。
構文
writeBin(object, con)
readBin(con, what, n )以下は、使用されるパラメータの説明です-
- con は、バイナリファイルを読み書きする接続オブジェクトです。
- object は書き込まれるバイナリファイルです。
- what は、文字、整数などのモードです。 読み込むバイトを表します。
- n は、バイナリファイルから読み取るバイト数です。
例
Rの組み込みデータ「mtcars」を考慮します。 まず、csvファイルを作成してバイナリファイルに変換し、OSファイルとして保存します。 次に、Rに作成されたこのバイナリファイルを読み取ります。
バイナリファイルの作成
データフレーム「mtcars」をcsvファイルとして読み取り、バイナリファイルとしてOSに書き込みます。
# Read the "mtcars" data frame as a csv file and store only the columns
"cyl", "am" and "gear".
write.table(mtcars, file = "mtcars.csv",row.names = FALSE, na = "",
col.names = TRUE, sep = ",")
# Store 5 records from the csv file as a new data frame.
new.mtcars <- read.table("mtcars.csv",sep = ",",header = TRUE,nrows = 5)
# Create a connection object to write the binary file using mode "wb".
write.filename = file("/web/com/binmtcars.dat", "wb")
# Write the column names of the data frame to the connection object.
writeBin(colnames(new.mtcars), write.filename)
# Write the records in each of the column to the file.
writeBin(c(new.mtcars$cyl,new.mtcars$am,new.mtcars$gear), write.filename)
# Close the file for writing so that it can be read by other program.
close(write.filename)バイナリファイルの読み取り
上記で作成されたバイナリファイルは、すべてのデータを連続したバイトとして保存します。 したがって、列の値と同様に列名の適切な値を選択して読み取ります。
# Create a connection object to read the file in binary mode using "rb".
read.filename <- file("/web/com/binmtcars.dat", "rb")
# First read the column names. n = 3 as we have 3 columns.
column.names <- readBin(read.filename, character(), n = 3)
# Next read the column values. n = 18 as we have 3 column names and 15 values.
read.filename <- file("/web/com/binmtcars.dat", "rb")
bindata <- readBin(read.filename, integer(), n = 18)
# Print the data.
print(bindata)
# Read the values from 4th byte to 8th byte which represents "cyl".
cyldata = bindata[4:8]
print(cyldata)
# Read the values form 9th byte to 13th byte which represents "am".
amdata = bindata[9:13]
print(amdata)
# Read the values form 9th byte to 13th byte which represents "gear".
geardata = bindata[14:18]
print(geardata)
# Combine all the read values to a dat frame.
finaldata = cbind(cyldata, amdata, geardata)
colnames(finaldata) = column.names
print(finaldata)上記のコードを実行すると、次の結果とグラフが生成されます-
[1] 7108963 1728081249 7496037 6 6 4
[7] 6 8 1 1 1 0
[13] 0 4 4 4 3 3
[1] 6 6 4 6 8
[1] 1 1 1 0 0
[1] 4 4 4 3 3
cyl am gear
[1,] 6 1 4
[2,] 6 1 4
[3,] 4 1 4
[4,] 6 0 3
[5,] 8 0 3ご覧のとおり、Rのバイナリファイルを読み取ることで元のデータを取得しました。
R-XMLファイル
XMLは、ファイル形式とWorld Wide Web、イントラネット、および標準ASCIIテキストを使用する他の場所のデータの両方を共有するファイル形式です。 Extensible Markup Language（XML）の略です。 HTMLと同様に、マークアップタグが含まれています。 しかし、マークアップタグがページの構造を記述するHTMLとは異なり、xmlではマークアップタグはファイルに含まれるデータの意味を記述します。
「XML」パッケージを使用して、Rでxmlファイルを読み取ることができます。 このパッケージは、次のコマンドを使用してインストールできます。
install.packages("XML")入力データ
以下のデータをメモ帳などのテキストエディターにコピーして、XMlファイルを作成します。 .xml 拡張子を付けてファイルを保存し、* all files（。）*としてファイルタイプを選択します。
<RECORDS>
<EMPLOYEE>
<ID>1</ID>
<NAME>Rick</NAME>
<SALARY>623.3</SALARY>
<STARTDATE>1/1/2012</STARTDATE>
<DEPT>IT</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>2</ID>
<NAME>Dan</NAME>
<SALARY>515.2</SALARY>
<STARTDATE>9/23/2013</STARTDATE>
<DEPT>Operations</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>3</ID>
<NAME>Michelle</NAME>
<SALARY>611</SALARY>
<STARTDATE>11/15/2014</STARTDATE>
<DEPT>IT</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>4</ID>
<NAME>Ryan</NAME>
<SALARY>729</SALARY>
<STARTDATE>5/11/2014</STARTDATE>
<DEPT>HR</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>5</ID>
<NAME>Gary</NAME>
<SALARY>843.25</SALARY>
<STARTDATE>3/27/2015</STARTDATE>
<DEPT>Finance</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>6</ID>
<NAME>Nina</NAME>
<SALARY>578</SALARY>
<STARTDATE>5/21/2013</STARTDATE>
<DEPT>IT</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>7</ID>
<NAME>Simon</NAME>
<SALARY>632.8</SALARY>
<STARTDATE>7/30/2013</STARTDATE>
<DEPT>Operations</DEPT>
</EMPLOYEE>
<EMPLOYEE>
<ID>8</ID>
<NAME>Guru</NAME>
<SALARY>722.5</SALARY>
<STARTDATE>6/17/2014</STARTDATE>
<DEPT>Finance</DEPT>
</EMPLOYEE>
</RECORDS>XMLファイルの読み取り
xmlファイルは、関数* xmlParse（）*を使用してRによって読み取られます。 Rにリストとして保存されます。
# Load the package required to read XML files.
library("XML")
# Also load the other required package.
library("methods")
# Give the input file name to the function.
result <- xmlParse(file = "input.xml")
# Print the result.
print(result)上記のコードを実行すると、次の結果が生成されます-
1
Rick
623.3
1/1/2012
IT
2
Dan
515.2
9/23/2013
Operations
3
Michelle
611
11/15/2014
IT
4
Ryan
729
5/11/2014
HR
5
Gary
843.25
3/27/2015
Finance
6
Nina
578
5/21/2013
IT
7
Simon
632.8
7/30/2013
Operations
8
Guru
722.5
6/17/2014
FinanceXMLファイルに存在するノードの数を取得する
# Load the packages required to read XML files.
library("XML")
library("methods")
# Give the input file name to the function.
result <- xmlParse(file = "input.xml")
# Exract the root node form the xml file.
rootnode <- xmlRoot(result)
# Find number of nodes in the root.
rootsize <- xmlSize(rootnode)
# Print the result.
print(rootsize)上記のコードを実行すると、次の結果が生成されます-
output
[1] 8最初のノードの詳細
解析されたファイルの最初のレコードを見てみましょう。 これにより、最上位ノードに存在するさまざまな要素がわかります。
# Load the packages required to read XML files.
library("XML")
library("methods")
# Give the input file name to the function.
result <- xmlParse(file = "input.xml")
# Exract the root node form the xml file.
rootnode <- xmlRoot(result)
# Print the result.
print(rootnode[1])上記のコードを実行すると、次の結果が生成されます-
$EMPLOYEE
1
Rick
623.3
1/1/2012
IT
attr(,"class")
[1] "XMLInternalNodeList" "XMLNodeList"ノードのさまざまな要素を取得する
# Load the packages required to read XML files.
library("XML")
library("methods")
# Give the input file name to the function.
result <- xmlParse(file = "input.xml")
# Exract the root node form the xml file.
rootnode <- xmlRoot(result)
# Get the first element of the first node.
print(rootnode[[Get the fifth element of the first node.
print(rootnode[[Get the second element of the third node.
print(rootnode[[When we execute the above code, it produces the following result −
[source,result,notranslate]1 ITミシェル
=== XML to Data Frame
To handle the data effectively in large files we read the data in the xml file as a data frame. Then process the data frame for data analysis.
[source,prettyprint,notranslate]＃XMLファイルの読み取りに必要なパッケージをロードします。 library（ "XML"）library（ "methods"）
＃入力xmlファイルをデータフレームに変換します。 xmldataframe ←xmlToDataFrame（ "input.xml"）print（xmldataframe）
When we execute the above code, it produces the following result −
[source,result,notranslate]ID名給与開始日DEPT 1 1 Rick 623.30 2012-01-01 IT 2 2 Dan 515.20 2013-09-23 Operations 3 3 Michelle 611.00 2014-11-15 IT 4 4 Ryan 729.00 2014-05-11 HR 5 NA Gary 843.25 2015 -03-27ファイナンス6 6ニーナ578.00 2013-05-21 IT 7 7サイモン632.80 2013-07-30オペレーション8 8グル722.50 2014-06-17ファイナンス
As the data is now available as a dataframe we can use data frame related function to read and manipulate the file.R-JSONファイル
JSONファイルは、データを人間が読める形式のテキストとして保存します。 JsonはJavaScript Object Notationの略です。 Rは、rjsonパッケージを使用してJSONファイルを読み取ることができます。
rjsonパッケージをインストールする
Rコンソールで、次のコマンドを発行してrjsonパッケージをインストールできます。
install.packages("rjson")入力データ
以下のデータをメモ帳などのテキストエディターにコピーして、JSONファイルを作成します。 .json 拡張子を付けてファイルを保存し、* all files（。）*としてファイルタイプを選択します。
{
"ID":["1","2","3","4","5","6","7","8" ],
"Name":["Rick","Dan","Michelle","Ryan","Gary","Nina","Simon","Guru" ],
"Salary":["623.3","515.2","611","729","843.25","578","632.8","722.5" ],
"StartDate":[ "1/1/2012","9/23/2013","11/15/2014","5/11/2014","3/27/2015","5/21/2013",
"7/30/2013","6/17/2014"],
"Dept":[ "IT","Operations","IT","HR","Finance","IT","Operations","Finance"]
}JSONファイルを読む
JSONファイルは、* JSON（）*の関数を使用してRによって読み取られます。 Rにリストとして保存されます。
# Load the package required to read JSON files.
library("rjson")
# Give the input file name to the function.
result <- fromJSON(file = "input.json")
# Print the result.
print(result)上記のコードを実行すると、次の結果が生成されます-
$ID
[1] "1" "2" "3" "4" "5" "6" "7" "8"
$Name
[1] "Rick" "Dan" "Michelle" "Ryan" "Gary" "Nina" "Simon" "Guru"
$Salary
[1] "623.3" "515.2" "611" "729" "843.25" "578" "632.8" "722.5"
$StartDate
[1] "1/1/2012" "9/23/2013" "11/15/2014" "5/11/2014" "3/27/2015" "5/21/2013"
"7/30/2013" "6/17/2014"
$Dept
[1] "IT" "Operations" "IT" "HR" "Finance" "IT"
"Operations" "Finance"JSONをデータフレームに変換する
- as.data.frame（）*関数を使用して、上記の抽出データをさらに分析するためにRデータフレームに変換できます。
# Load the package required to read JSON files.
library("rjson")
# Give the input file name to the function.
result <- fromJSON(file = "input.json")
# Convert JSON file to a data frame.
json_data_frame <- as.data.frame(result)
print(json_data_frame)上記のコードを実行すると、次の結果が生成されます-
id, name, salary, start_date, dept
1 1 Rick 623.30 2012-01-01 IT
2 2 Dan 515.20 2013-09-23 Operations
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 NA Gary 843.25 2015-03-27 Finance
6 6 Nina 578.00 2013-05-21 IT
7 7 Simon 632.80 2013-07-30 Operations
8 8 Guru 722.50 2014-06-17 FinanceR-Webデータ
多くのWebサイトは、ユーザーが使用するデータを提供しています。 たとえば、世界保健機関（WHO）は、CSV、txt、およびXMLファイルの形式で健康および医療情報に関するレポートを提供しています。 Rプログラムを使用すると、このようなWebサイトから特定のデータをプログラムで抽出できます。 Webからデータをスクラップするために使用されるRのパッケージには、「RCurl」、「XML」、および「stringr」があります。 URLに接続し、ファイルに必要なリンクを特定して、ローカル環境にダウンロードするために使用されます。
Rパッケージをインストールする
URLとファイルへのリンクを処理するには、次のパッケージが必要です。 R環境で使用できない場合は、次のコマンドを使用してインストールできます。
install.packages("RCurl")
install.packages("XML")
install.packages("stringr")
install.packages("plyr")入力データ
URL 天気データにアクセスし、2015年のRを使用してCSVファイルをダウンロードします。
例
関数* getHTMLLinks（）を使用して、ファイルのURLを収集します。 次に、関数 download.file（）*を使用して、ファイルをローカルシステムに保存します。 同じコードを複数のファイルに何度も適用するため、複数回呼び出される関数を作成します。 ファイル名は、Rリストオブジェクトの形式でパラメーターとしてこの関数に渡されます。
# Read the URL.
url <- "http://www.geos.ed.ac.uk/~weather/jcmb_ws/"
# Gather the html links present in the webpage.
links <- getHTMLLinks(url)
# Identify only the links which point to the JCMB 2015 files.
filenames <- links[str_detect(links, "JCMB_2015")]
# Store the file names as a list.
filenames_list <- as.list(filenames)
# Create a function to download the files by passing the URL and filename list.
downloadcsv <- function (mainurl,filename) {
filedetails <- str_c(mainurl,filename)
download.file(filedetails,filename)
}
# Now apply the l_ply function and save the files into the current R working directory.
l_ply(filenames,downloadcsv,mainurl = "http://www.geos.ed.ac.uk/~weather/jcmb_ws/")ファイルのダウンロードを確認する
上記のコードを実行すると、現在のR作業ディレクトリで次のファイルを見つけることができます。
"JCMB_2015.csv" "JCMB_2015_Apr.csv" "JCMB_2015_Feb.csv" "JCMB_2015_Jan.csv"
"JCMB_2015_Mar.csv"R-データベース
データは、リレーショナルデータベースシステムが正規化された形式で保存されます。 したがって、統計計算を実行するには、非常に高度で複雑なSqlクエリが必要になります。 しかし、RはMySql、Oracle、Sqlサーバーなどの多くのリレーショナルデータベースに簡単に接続できます。 それらからレコードをデータフレームとして取得します。 R環境でデータが使用可能になると、通常のRデータセットになり、すべての強力なパッケージと機能を使用して操作または分析できます。
このチュートリアルでは、Rに接続するための参照データベースとしてMySqlを使用します。
RMySQLパッケージ
Rには「RMySQL」という名前の組み込みパッケージがあり、MySqlデータベースとのネイティブ接続を提供します。 次のコマンドを使用して、このパッケージをR環境にインストールできます。
install.packages("RMySQL")RをMySqlに接続する
パッケージをインストールしたら、Rに接続オブジェクトを作成してデータベースに接続します。 ユーザー名、パスワード、データベース名、ホスト名を入力として受け取ります。
# Create a connection Object to MySQL database.
# We will connect to the sampel database named "sakila" that comes with MySql installation.
mysqlconnection = dbConnect(MySQL(), user = 'root', password = '', dbname = 'sakila',
host = 'localhost')
# List the tables available in this database.
dbListTables(mysqlconnection)上記のコードを実行すると、次の結果が生成されます-
[1] "actor" "actor_info"
[3] "address" "category"
[5] "city" "country"
[7] "customer" "customer_list"
[9] "film" "film_actor"
[11] "film_category" "film_list"
[13] "film_text" "inventory"
[15] "language" "nicer_but_slower_film_list"
[17] "payment" "rental"
[19] "sales_by_film_category" "sales_by_store"
[21] "staff" "staff_list"
[23] "store"テーブルのクエリ
関数* dbSendQuery（）*を使用して、MySqlのデータベーステーブルをクエリできます。 クエリはMySqlで実行され、R * fetch（）*関数を使用して結果セットが返されます。 最後に、データフレームとしてRに保存されます。
# Query the "actor" tables to get all the rows.
result = dbSendQuery(mysqlconnection, "select *from actor")
# Store the result in a R data frame object. n = 5 is used to fetch first 5 rows.
data.frame = fetch(result, n = 5)
print(data.fame)上記のコードを実行すると、次の結果が生成されます-
actor_id first_name last_name last_update
1 1 PENELOPE GUINESS 2006-02-15 04:34:33
2 2 NICK WAHLBERG 2006-02-15 04:34:33
3 3 ED CHASE 2006-02-15 04:34:33
4 4 JENNIFER DAVIS 2006-02-15 04:34:33
5 5 JOHNNY LOLLOBRIGIDA 2006-02-15 04:34:33フィルター句を使用したクエリ
有効な選択クエリを渡して結果を取得できます。
result = dbSendQuery(mysqlconnection, "select* from actor where last_name = 'TORN'")
# Fetch all the records(with n = -1) and store it as a data frame.
data.frame = fetch(result, n = -1)
print(data)上記のコードを実行すると、次の結果が生成されます-
actor_id first_name last_name last_update
1 18 DAN TORN 2006-02-15 04:34:33
2 94 KENNETH TORN 2006-02-15 04:34:33
3 102 WALTER TORN 2006-02-15 04:34:33テーブルの行を更新する
更新クエリをdbSendQuery（）関数に渡すことで、Mysqlテーブルの行を更新できます。
dbSendQuery(mysqlconnection, "update mtcars set disp = 168.5 where hp = 110")上記のコードを実行すると、MySql環境で更新されたテーブルを確認できます。
テーブルへのデータの挿入
dbSendQuery(mysqlconnection,
"insert into mtcars(row_names, mpg, cyl, disp, hp, drat, wt, qsec, vs, am, gear, carb)
values('New Mazda RX4 Wag', 21, 6, 168.5, 110, 3.9, 2.875, 17.02, 0, 1, 4, 4)"
)上記のコードを実行すると、MySql環境のテーブルに挿入された行が表示されます。
MySqlでテーブルを作成する
関数* dbWriteTable（）*を使用して、MySqlにテーブルを作成できます。 テーブルが既に存在する場合は上書きし、データフレームを入力として受け取ります。
# Create the connection object to the database where we want to create the table.
mysqlconnection = dbConnect(MySQL(), user = 'root', password = '', dbname = 'sakila',
host = 'localhost')
# Use the R data frame "mtcars" to create the table in MySql.
# All the rows of mtcars are taken inot MySql.
dbWriteTable(mysqlconnection, "mtcars", mtcars[, ], overwrite = TRUE)上記のコードを実行すると、MySql環境で作成されたテーブルが表示されます。
MySqlでのテーブルの削除
テーブルからデータをクエリするのに使用したのと同じ方法で、ドロップテーブルステートメントをdbSendQuery（）に渡して、MySqlデータベースのテーブルをドロップできます。
dbSendQuery(mysqlconnection, 'drop table if exists mtcars')上記のコードを実行すると、MySql環境でテーブルが削除されていることがわかります。
R-円グラフ
Rプログラミング言語には、チャートやグラフを作成するための多数のライブラリがあります。 円グラフは、異なる色の円のスライスとしての値の表現です。 スライスにはラベルが付けられ、各スライスに対応する番号もチャートに表示されます。
Rでは、円グラフは、ベクトル入力として正の数を取る* pie（）*関数を使用して作成されます。 追加のパラメーターは、ラベル、色、タイトルなどを制御するために使用されます。
構文
Rを使用して円グラフを作成するための基本的な構文は次のとおりです-
pie(x, labels, radius, main, col, clockwise)以下は、使用されるパラメータの説明です-
- x は、円グラフで使用される数値を含むベクトルです。
- labels は、スライスの説明に使用されます。
- radius は、円グラフの円の半径を示します（-1から＆plus; 1までの値）。
- main はチャートのタイトルを示します。
- col はカラーパレットを示します。
- clockwise は、スライスが時計回りに描かれるか反時計回りに描かれるかを示す論理値です。
例
入力ベクトルとラベルだけを使用して、非常に単純な円グラフが作成されます。 以下のスクリプトは、現在のR作業ディレクトリに円グラフを作成して保存します。
# Create data for the graph.
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")
# Give the chart file a name.
png(file = "city.jpg")
# Plot the chart.
pie(x,labels)
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
円グラフのタイトルと色
関数にさらにパラメーターを追加することで、チャートの機能を拡張できます。 パラメーター main を使用してチャートにタイトルを追加し、別のパラメーターは col で、チャートの描画中にレインボーカラーパレットを使用します。 パレットの長さは、チャートの値の数と同じにする必要があります。 したがって、length（x）を使用します。
例
以下のスクリプトは、現在のR作業ディレクトリに円グラフを作成して保存します。
# Create data for the graph.
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")
# Give the chart file a name.
png(file = "city_title_colours.jpg")
# Plot the chart with title and rainbow color pallet.
pie(x, labels, main = "City pie chart", col = rainbow(length(x)))
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
スライスの割合とグラフの凡例
追加のグラフ変数を作成して、スライスの割合とグラフの凡例を追加できます。
# Create data for the graph.
x <- c(21, 62, 10,53)
labels <- c("London","New York","Singapore","Mumbai")
piepercent<- round(100*x/sum(x), 1)
# Give the chart file a name.
png(file = "city_percentage_legends.jpg")
# Plot the chart.
pie(x, labels = piepercent, main = "City pie chart",col = rainbow(length(x)))
legend("topright", c("London","New York","Singapore","Mumbai"), cex = 0.8,
fill = rainbow(length(x)))
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
立体円グラフ
追加のパッケージを使用して、3次元の円グラフを描画できます。 パッケージ plotrix には、これに使用される* pie3D（）*という関数があります。
# Get the library.
library(plotrix)
# Create data for the graph.
x <- c(21, 62, 10,53)
lbl <- c("London","New York","Singapore","Mumbai")
# Give the chart file a name.
png(file = "3d_pie_chart.jpg")
# Plot the chart.
pie3D(x,labels = lbl,explode = 0.1, main = "Pie Chart of Countries ")
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
R-棒グラフ
棒グラフは、変数の値に比例する棒の長さを持つ長方形の棒でデータを表します。 Rは、関数* barplot（）*を使用して棒グラフを作成します。 Rは、棒グラフに垂直バーと水平バーの両方を描画できます。 棒グラフでは、各棒に異なる色を付けることができます。
構文
Rで棒グラフを作成するための基本的な構文は次のとおりです-
barplot(H,xlab,ylab,main, names.arg,col)以下は、使用されるパラメータの説明です-
- H は、棒グラフで使用される数値を含むベクトルまたは行列です。
- xlab はx軸のラベルです。
- ylab はy軸のラベルです。
- main は棒グラフのタイトルです。
- names.arg は、各バーの下に表示される名前のベクトルです。
- col は、グラフのバーに色を付けるために使用されます。
例
入力ベクトルと各バーの名前だけを使用して、単純な棒グラフが作成されます。
以下のスクリプトは、現在のR作業ディレクトリに棒グラフを作成して保存します。
# Create the data for the chart
H <- c(7,12,28,3,41)
# Give the chart file a name
png(file = "barchart.png")
# Plot the bar chart
barplot(H)
# Save the file
dev.off()上記のコードを実行すると、次の結果が生成されます-
棒グラフのラベル、タイトル、色
棒グラフの機能は、パラメーターを追加することで拡張できます。 main パラメーターは、 title を追加するために使用されます。 col パラメーターは、バーに色を追加するために使用されます。 args.name は、各バーの意味を説明する入力ベクトルと同じ数の値を持つベクトルです。
例
以下のスクリプトは、現在のR作業ディレクトリに棒グラフを作成して保存します。
# Create the data for the chart
H <- c(7,12,28,3,41)
M <- c("Mar","Apr","May","Jun","Jul")
# Give the chart file a name
png(file = "barchart_months_revenue.png")
# Plot the bar chart
barplot(H,names.arg=M,xlab="Month",ylab="Revenue",col="blue",
main="Revenue chart",border="red")
# Save the file
dev.off()上記のコードを実行すると、次の結果が生成されます-
グループ棒グラフと積み上げ棒グラフ
入力値として行列を使用することで、棒のグループと各棒のスタックで棒グラフを作成できます。
3つ以上の変数は、グループ棒グラフと積み上げ棒グラフの作成に使用されるマトリックスとして表されます。
# Create the input vectors.
colors = c("green","orange","brown")
months <- c("Mar","Apr","May","Jun","Jul")
regions <- c("East","West","North")
# Create the matrix of the values.
Values <- matrix(c(2,9,3,11,9,4,8,7,3,12,5,2,8,10,11), nrow = 3, ncol = 5, byrow = TRUE)
# Give the chart file a name
png(file = "barchart_stacked.png")
# Create the bar chart
barplot(Values, main = "total revenue", names.arg = months, xlab = "month", ylab = "revenue", col = colors)
# Add the legend to the chart
legend("topleft", regions, cex = 1.3, fill = colors)
# Save the file
dev.off()R-ボックスプロット
箱ひげ図は、データセット内のデータがどれだけ適切に分散されているかの尺度です。 データセットを3つの四分位数に分割します。 このグラフは、データセットの最小値、最大値、中央値、最初の四分位数、3番目の四分位数を表します。 また、データセットごとに箱ひげ図を描くことにより、データセット全体でデータの分布を比較するのにも役立ちます。
ボックスプロットは、* boxplot（）*関数を使用してRで作成されます。
構文
Rで箱ひげ図を作成するための基本的な構文は次のとおりです-
boxplot(x, data, notch, varwidth, names, main)以下は、使用されるパラメータの説明です-
- x はベクトルまたは数式です。
- data はデータフレームです。
- notch は論理値です。 ノッチを描画するにはTRUEに設定します。
- varwidth は論理値です。 サンプルサイズに比例してボックスの幅を描画するには、trueに設定します。
- names は、各箱ひげ図の下に印刷されるグループラベルです。
- main は、グラフにタイトルを付けるために使用されます。
例
R環境で使用可能なデータセット「mtcars」を使用して、基本的な箱ひげ図を作成します。 mtcarsの「mpg」列と「cyl」列を見てみましょう。
input <- mtcars[,c('mpg','cyl')]
print(head(input))上記のコードを実行すると、次の結果が生成されます-
mpg cyl
Mazda RX4 21.0 6
Mazda RX4 Wag 21.0 6
Datsun 710 22.8 4
Hornet 4 Drive 21.4 6
Hornet Sportabout 18.7 8
Valiant 18.1 6Boxplotの作成
以下のスクリプトは、mpg（1ガロンあたりのマイル数）とcyl（シリンダーの数）の関係を表す箱ひげ図を作成します。
# Give the chart file a name.
png(file = "boxplot.png")
# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars, xlab = "Number of Cylinders",
ylab = "Miles Per Gallon", main = "Mileage Data")
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
ノッチ付きボックスプロット
ノッチ付きの箱ひげ図を描画して、異なるデータグループの中央値が互いにどのように一致するかを調べることができます。
以下のスクリプトは、データグループごとにノッチ付きの箱ひげ図グラフを作成します。
# Give the chart file a name.
png(file = "boxplot_with_notch.png")
# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars,
xlab = "Number of Cylinders",
ylab = "Miles Per Gallon",
main = "Mileage Data",
notch = TRUE,
varwidth = TRUE,
col = c("green","yellow","purple"),
names = c("High","Medium","Low")
)
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
R-ヒストグラム
ヒストグラムは、範囲にバケット化された変数の値の頻度を表します。 ヒストグラムはバーチャットに似ていますが、違いは値を連続した範囲にグループ化することです。 ヒストグラムの各バーは、その範囲に存在する値の数の高さを表します。
Rは、* hist（）*関数を使用してヒストグラムを作成します。 この関数は、ベクトルを入力として受け取り、いくつかのパラメーターを使用してヒストグラムをプロットします。
構文
Rを使用してヒストグラムを作成するための基本的な構文は次のとおりです-
hist(v,main,xlab,xlim,ylim,breaks,col,border)以下は、使用されるパラメータの説明です-
- v は、ヒストグラムで使用される数値を含むベクトルです。
- main はチャートのタイトルを示します。
- col はバーの色を設定するために使用されます。
- border は各バーの境界線の色を設定するために使用されます。
- xlab は、x軸の説明に使用されます。
- xlim は、x軸の値の範囲を指定するために使用されます。
- ylim は、y軸の値の範囲を指定するために使用されます。
- breaks は、各バーの幅を示すために使用されます。
例
入力ベクトル、ラベル、列および境界線パラメーターを使用して、単純なヒストグラムが作成されます。
以下のスクリプトは、現在のR作業ディレクトリにヒストグラムを作成して保存します。
# Create data for the graph.
v <- c(9,13,21,8,36,22,12,41,31,33,19)
# Give the chart file a name.
png(file = "histogram.png")
# Create the histogram.
hist(v,xlab = "Weight",col = "yellow",border = "blue")
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
XおよびY値の範囲
X軸とY軸で許可される値の範囲を指定するには、xlimパラメーターとylimパラメーターを使用できます。
各バーの幅は、ブレークを使用して決定できます。
# Create data for the graph.
v <- c(9,13,21,8,36,22,12,41,31,33,19)
# Give the chart file a name.
png(file = "histogram_lim_breaks.png")
# Create the histogram.
hist(v,xlab = "Weight",col = "green",border = "red", xlim = c(0,40), ylim = c(0,5),
breaks = 5)
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
R-折れ線グラフ
折れ線グラフは、一連のポイントの間に線セグメントを描画することで、それらを接続するグラフです。 これらのポイントは、座標（通常はx座標）値の1つで順序付けられます。 通常、折れ線グラフは、データの傾向を識別するために使用されます。
Rの* plot（）*関数は、折れ線グラフを作成するために使用されます。
構文
Rで折れ線グラフを作成するための基本的な構文は次のとおりです-
plot(v,type,col,xlab,ylab)以下は、使用されるパラメータの説明です-
- v は数値を含むベクトルです。
- type は、値 "p"を使用して点のみを描画し、 "l"を使用して線のみを描画し、 "o"を使用して点と線の両方を描画します。
- xlab はx軸のラベルです。
- ylab はy軸のラベルです。
- main はチャートのタイトルです。
- col は、ポイントとラインの両方に色を付けるために使用されます。
例
入力ベクトルと「O」としての型パラメーターを使用して、単純な折れ線グラフが作成されます。 以下のスクリプトは、現在のR作業ディレクトリに折れ線グラフを作成して保存します。
# Create the data for the chart.
v <- c(7,12,28,3,41)
# Give the chart file a name.
png(file = "line_chart.jpg")
# Plot the bar chart.
plot(v,type = "o")
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
折れ線グラフのタイトル、色、ラベル
追加のパラメーターを使用して、折れ線グラフの機能を拡張できます。 ポイントとラインに色を追加し、チャートにタイトルを付け、軸にラベルを追加します。
例
# Create the data for the chart.
v <- c(7,12,28,3,41)
# Give the chart file a name.
png(file = "line_chart_label_colored.jpg")
# Plot the bar chart.
plot(v,type = "o", col = "red", xlab = "Month", ylab = "Rain fall",
main = "Rain fall chart")
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
折れ線グラフの複数の線
- lines（）**関数を使用して、同じチャートに複数の線を描画できます。
最初の線がプロットされた後、lines（）関数は追加のベクトルを入力として使用して、チャートに2番目の線を描画できます。
# Create the data for the chart.
v <- c(7,12,28,3,41)
t <- c(14,7,6,19,3)
# Give the chart file a name.
png(file = "line_chart_2_lines.jpg")
# Plot the bar chart.
plot(v,type = "o",col = "red", xlab = "Month", ylab = "Rain fall",
main = "Rain fall chart")
lines(t, type = "o", col = "blue")
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
R-散布図
散布図には、デカルト平面にプロットされた多くの点が表示されます。 各ポイントは、2つの変数の値を表します。 1つの変数は水平軸で選択され、別の変数は垂直軸で選択されます。
単純な散布図は、* plot（）*関数を使用して作成されます。
構文
Rで散布図を作成するための基本的な構文は次のとおりです-
plot(x, y, main, xlab, ylab, xlim, ylim, axes)以下は、使用されるパラメータの説明です-
- x は、値が水平座標であるデータセットです。
- y は、値が垂直座標であるデータセットです。
- main はグラフのタイルです。
- xlab は水平軸のラベルです。
- ylab は垂直軸のラベルです。
- xlim は、プロットに使用されるxの値の制限です。
- ylim は、プロットに使用されるyの値の制限です。
- axes は、両方の軸をプロットに描画するかどうかを示します。
例
R環境で使用可能なデータセット "mtcars" を使用して、基本的な散布図を作成します。 mtcarsの「wt」列と「mpg」列を使用してみましょう。
input <- mtcars[,c('wt','mpg')]
print(head(input))上記のコードを実行すると、次の結果が生成されます-
wt mpg
Mazda RX4 2.620 21.0
Mazda RX4 Wag 2.875 21.0
Datsun 710 2.320 22.8
Hornet 4 Drive 3.215 21.4
Hornet Sportabout 3.440 18.7
Valiant 3.460 18.1散布図の作成
以下のスクリプトは、wt（weight）とmpg（miles per gallon）の関係の散布図グラフを作成します。
# Get the input values.
input <- mtcars[,c('wt','mpg')]
# Give the chart file a name.
png(file = "scatterplot.png")
# Plot the chart for cars with weight between 2.5 to 5 and mileage between 15 and 30.
plot(x = input$wt,y = input$mpg,
xlab = "Weight",
ylab = "Milage",
xlim = c(2.5,5),
ylim = c(15,30),
main = "Weight vs Milage"
)
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
散布図行列
3つ以上の変数があり、1つの変数と残りの変数との相関を見つけたい場合、散布図行列を使用します。 * pairs（）*関数を使用して、散布図の行列を作成します。
構文
Rで散布図行列を作成するための基本的な構文は次のとおりです-
pairs(formula, data)以下は、使用されるパラメータの説明です-
- *式*は、ペアで使用される一連の変数を表します。
- data は、変数が取得されるデータセットを表します。
例
各変数は、残りの各変数とペアになっています。 散布図が各ペアに対してプロットされます。
# Give the chart file a name.
png(file = "scatterplot_matrices.png")
# Plot the matrices between 4 variables giving 12 plots.
# One variable with 3 others and total 4 variables.
pairs(~wt+mpg+disp+cyl,data = mtcars,
main = "Scatterplot Matrix")
# Save the file.
dev.off()上記のコードを実行すると、次の出力が得られます。
R-平均、中央値、モード
Rの統計分析は、多くの組み込み関数を使用して実行されます。 これらの関数のほとんどは、Rベースパッケージの一部です。 これらの関数は、引数とともにRベクトルを入力として受け取り、結果を返します。
この章で説明する関数は、平均値、中央値、モードです。
Mean
値の合計を取り、データ系列の値の数で割ることによって計算されます。
関数* mean（）*は、Rでこれを計算するために使用されます。
構文
Rの平均を計算するための基本的な構文は次のとおりです-
mean(x, trim = 0, na.rm = FALSE, ...)以下は、使用されるパラメータの説明です-
- x は入力ベクトルです。
- trim は、ソートされたベクトルの両端からいくつかの観測値を削除するために使用されます。
- na.rm は、入力ベクトルから欠損値を削除するために使用されます。
例
# Create a vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)
# Find Mean.
result.mean <- mean(x)
print(result.mean)上記のコードを実行すると、次の結果が生成されます-
[1] 8.22トリムオプションの適用
トリムパラメーターを指定すると、ベクトルの値が並べ替えられ、必要な観測数が平均の計算から除外されます。
trim = 0.3の場合、各端から3つの値が計算から除外されて平均が求められます。
この場合、ソートされたベクトルは（-21、-5、2、3、4.2、7、8、12、18、54）であり、平均を計算するためにベクトルから削除された値は（-21、-5、2）です。左から（12,18,54）右から。
# Create a vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)
# Find Mean.
result.mean <- mean(x,trim = 0.3)
print(result.mean)上記のコードを実行すると、次の結果が生成されます-
[1] 5.55NAオプションの適用
欠損値がある場合、平均関数はNAを返します。
計算から欠損値を削除するには、na.rm = TRUEを使用します。 つまり、NA値を削除します。
# Create a vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5,NA)
# Find mean.
result.mean <- mean(x)
print(result.mean)
# Find mean dropping NA values.
result.mean <- mean(x,na.rm = TRUE)
print(result.mean)上記のコードを実行すると、次の結果が生成されます-
[1] NA
[1] 8.22中央値
データ系列の中央の値は中央値と呼ばれます。 * median（）*関数は、この値を計算するためにRで使用されます。
構文
Rの中央値を計算するための基本的な構文は次のとおりです-
median(x, na.rm = FALSE)以下は、使用されるパラメータの説明です-
- x は入力ベクトルです。
- na.rm は、入力ベクトルから欠損値を削除するために使用されます。
例
# Create the vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)
# Find the median.
median.result <- median(x)
print(median.result)上記のコードを実行すると、次の結果が生成されます-
[1] 5.6Mode
モードは、一連のデータ内で発生回数が最も多い値です。 Unikeの平均値と中央値、モードには数値データと文字データの両方が含まれます。
Rには、モードを計算するための標準の組み込み関数はありません。 そこで、Rのデータセットのモードを計算するユーザー関数を作成します。 この関数は、ベクトルを入力として受け取り、モード値を出力として提供します。
例
# Create the function.
getmode <- function(v) {
uniqv <- unique(v)
uniqv[which.max(tabulate(match(v, uniqv)))]
}
# Create the vector with numbers.
v <- c(2,1,2,3,1,2,3,4,1,5,5,3,2,3)
# Calculate the mode using the user function.
result <- getmode(v)
print(result)
# Create the vector with characters.
charv <- c("o","it","the","it","it")
# Calculate the mode using the user function.
result <- getmode(charv)
print(result)上記のコードを実行すると、次の結果が生成されます-
[1] 2
[1] "it"R-線形回帰
回帰分析は、2つの変数間の関係モデルを確立するために非常に広く使用されている統計ツールです。 これらの変数の1つは予測変数と呼ばれ、その変数の値は実験によって収集されます。 もう1つの変数は応答変数と呼ばれ、その変数の値は予測変数から派生します。
線形回帰では、これらの2つの変数は方程式を介して関連付けられます。これらの変数の指数（パワー）は1です。 数学的に線形関係は、グラフとしてプロットされたときに直線を表します。 変数の指数が1に等しくない非線形の関係は、曲線を作成します。
線形回帰の一般的な数学方程式は-
y = ax + b以下は、使用されるパラメータの説明です-
- y は応答変数です。
- x は予測変数です。
- a および b は、係数と呼ばれる定数です。
回帰を確立する手順
回帰の簡単な例は、身長がわかっているときに人の体重を予測することです。 これを行うには、身長と体重の関係が必要です。
関係を作成する手順は次のとおりです-
- 身長と対応する体重の観測値のサンプルを収集する実験を実行します。
- Rの* lm（）*関数を使用して関係モデルを作成します。
- 作成されたモデルから係数を見つけ、これらを使用して数式を作成します 関係モデルの概要を取得して、予測の平均誤差を把握します。 残差*とも呼ばれます。
- 新しい人の体重を予測するには、Rで* predict（）*関数を使用します。
入力データ
以下は、観測を表すサンプルデータです-
# Values of height
151, 174, 138, 186, 128, 136, 179, 163, 152, 131
# Values of weight.
63, 81, 56, 91, 47, 57, 76, 72, 62, 48lm（）関数
この関数は、予測変数と応答変数の間の関係モデルを作成します。
構文
線形回帰の* lm（）*関数の基本的な構文は-
lm(formula,data)以下は、使用されるパラメータの説明です-
- *式*は、xとyの関係を表す記号です。
- data は、式が適用されるベクトルです。
関係モデルを作成して係数を取得する
x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)
# Apply the lm() function.
relation <- lm(y~x)
print(relation)上記のコードを実行すると、次の結果が生成されます-
Call:
lm(formula = y ~ x)
Coefficients:
(Intercept) x
-38.4551 0.6746関係の概要を取得する
x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)
# Apply the lm() function.
relation <- lm(y~x)
print(summary(relation))上記のコードを実行すると、次の結果が生成されます-
Call:
lm(formula = y ~ x)
Residuals:
Min 1Q Median 3Q Max
-6.3002 -1.6629 0.0412 1.8944 3.9775
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) -38.45509 8.04901 -4.778 0.00139 * *
x 0.67461 0.05191 12.997 1.16e-06* **
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
Residual standard error: 3.253 on 8 degrees of freedom
Multiple R-squared: 0.9548, Adjusted R-squared: 0.9491
F-statistic: 168.9 on 1 and 8 DF, p-value: 1.164e-06predict（）関数
構文
線形回帰のpredict（）の基本的な構文は-
predict(object, newdata)以下は、使用されるパラメータの説明です-
- object は、lm（）関数を使用して既に作成されている式です。
- newdata は、予測変数の新しい値を含むベクトルです。
新しい人の体重を予測する
# The predictor vector.
x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
# The resposne vector.
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)
# Apply the lm() function.
relation <- lm(y~x)
# Find weight of a person with height 170.
a <- data.frame(x = 170)
result <- predict(relation,a)
print(result)上記のコードを実行すると、次の結果が生成されます-
1
76.22869回帰をグラフィカルに視覚化する
# Create the predictor and response variable.
x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)
relation <- lm(y~x)
# Give the chart file a name.
png(file = "linearregression.png")
# Plot the chart.
plot(y,x,col = "blue",main = "Height & Weight Regression",
abline(lm(x~y)),cex = 1.3,pch = 16,xlab = "Weight in Kg",ylab = "Height in cm")
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
R-重回帰
重回帰は、3つ以上の変数間の関係への線形回帰の拡張です。 単純な線形関係では1つの予測変数と1つの応答変数がありますが、重回帰では複数の予測変数と1つの応答変数があります。
重回帰の一般的な数学方程式は-
y = a + b1x1 + b2x2 +...bnxn以下は、使用されるパラメータの説明です-
- y は応答変数です。
- a、b1、b2 … bn は係数です。
- x1、x2、… xn は予測変数です。
Rの* lm（）*関数を使用して回帰モデルを作成します。 モデルは、入力データを使用して係数の値を決定します。 次に、これらの係数を使用して、予測変数の特定のセットの応答変数の値を予測できます。
lm（）関数
この関数は、予測変数と応答変数の間の関係モデルを作成します。
構文
重回帰の* lm（）*関数の基本的な構文は次のとおりです-
lm(y ~ x1+x2+x3...,data)以下は、使用されるパラメータの説明です-
- *式*は、応答変数と予測変数の間の関係を表す記号です。
- data は、式が適用されるベクトルです。
例
入力データ
R環境で使用可能なデータセット「mtcars」を検討してください。 ガロンあたりの走行距離（mpg）、シリンダー変位（ "disp"）、馬力（ "hp"）、車の重量（ "wt"）およびその他のパラメーターに関して、さまざまな車のモデルを比較します。
モデルの目標は、予測変数として「disp」、「hp」および「wt」と応答変数として「mpg」の関係を確立することです。 この目的のために、mtcarsデータセットからこれらの変数のサブセットを作成します。
input <- mtcars[,c("mpg","disp","hp","wt")]
print(head(input))上記のコードを実行すると、次の結果が生成されます-
mpg disp hp wt
Mazda RX4 21.0 160 110 2.620
Mazda RX4 Wag 21.0 160 110 2.875
Datsun 710 22.8 108 93 2.320
Hornet 4 Drive 21.4 258 110 3.215
Hornet Sportabout 18.7 360 175 3.440
Valiant 18.1 225 105 3.460関係モデルを作成して係数を取得する
input <- mtcars[,c("mpg","disp","hp","wt")]
# Create the relationship model.
model <- lm(mpg~disp+hp+wt, data = input)
# Show the model.
print(model)
# Get the Intercept and coefficients as vector elements.
cat("# # # # The Coefficient Values # # # ","\n")
a <- coef(model)[1]
print(a)
Xdisp <- coef(model)[2]
Xhp <- coef(model)[3]
Xwt <- coef(model)[4]
print(Xdisp)
print(Xhp)
print(Xwt)上記のコードを実行すると、次の結果が生成されます-
Call:
lm(formula = mpg ~ disp + hp + wt, data = input)
Coefficients:
(Intercept) disp hp wt
37.105505 -0.000937 -0.031157 -3.800891
# # # # The Coefficient Values # # #
(Intercept)
37.10551
disp
-0.0009370091
hp
-0.03115655
wt
-3.800891回帰モデルの方程式を作成
上記の切片と係数の値に基づいて、数学的な方程式を作成します。
Y = a+Xdisp.x1+Xhp.x2+Xwt.x3
or
Y = 37.15+(-0.000937)*x1+(-0.0311)*x2+(-3.8008)*x3新しい値を予測する方程式を適用
上記で作成した回帰式を使用して、排気量、馬力、体重の値の新しいセットが提供されたときの燃費を予測できます。
disp = 221、hp = 102、wt = 2.91の車の場合、予測走行距離は-
Y = 37.15+(-0.000937)*221+(-0.0311)*102+(-3.8008)*2.91 = 22.7104R-ロジスティック回帰
ロジスティック回帰は、応答変数（従属変数）がTrue/Falseまたは0/1などのカテゴリ値を持つ回帰モデルです。 実際には、予測変数に関連付けられた数式に基づいて、応答変数の値としてバイナリ応答の確率を測定します。
ロジスティック回帰の一般的な数学方程式は-
y = 1/(1+e^-(a+b1x1+b2x2+b3x3+...))以下は、使用されるパラメータの説明です-
- y は応答変数です。
- x は予測変数です。
- a および b は、数値定数である係数です。
回帰モデルの作成に使用される関数は* glm（）*関数です。
構文
ロジスティック回帰の* glm（）*関数の基本的な構文は次のとおりです-
glm(formula,data,family)以下は、使用されるパラメータの説明です-
- *式*は、変数間の関係を表す記号です。
- data は、これらの変数の値を提供するデータセットです。
- family は、モデルの詳細を指定するRオブジェクトです。 ロジスティック回帰の値は二項です。
例
組み込みのデータセット「mtcars」は、さまざまなエンジン仕様を持つ自動車のさまざまなモデルを記述しています。 「mtcars」データセットでは、伝送モード（自動または手動）は、バイナリ値（0または1）である列amによって記述されます。 「am」列と他の3つの列（hp、wt、cyl）の間でロジスティック回帰モデルを作成できます。
# Select some columns form mtcars.
input <- mtcars[,c("am","cyl","hp","wt")]
print(head(input))上記のコードを実行すると、次の結果が生成されます-
am cyl hp wt
Mazda RX4 1 6 110 2.620
Mazda RX4 Wag 1 6 110 2.875
Datsun 710 1 4 93 2.320
Hornet 4 Drive 0 6 110 3.215
Hornet Sportabout 0 8 175 3.440
Valiant 0 6 105 3.460回帰モデルを作成する
- glm（）*関数を使用して回帰モデルを作成し、分析のためにその要約を取得します。
input <- mtcars[,c("am","cyl","hp","wt")]
am.data = glm(formula = am ~ cyl + hp + wt, data = input, family = binomial)
print(summary(am.data))上記のコードを実行すると、次の結果が生成されます-
Call:
glm(formula = am ~ cyl + hp + wt, family = binomial, data = input)
Deviance Residuals:
Min 1Q Median 3Q Max
-2.17272 -0.14907 -0.01464 0.14116 1.27641
Coefficients:
Estimate Std. Error z value Pr(>|z|)
(Intercept) 19.70288 8.11637 2.428 0.0152 *
cyl 0.48760 1.07162 0.455 0.6491
hp 0.03259 0.01886 1.728 0.0840 .
wt -9.14947 4.15332 -2.203 0.0276 *
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
(Dispersion parameter for binomial family taken to be 1)
Null deviance: 43.2297 on 31 degrees of freedom
Residual deviance: 9.8415 on 28 degrees of freedom
AIC: 17.841
Number of Fisher Scoring iterations: 8結論
最後の列のp値が変数「cyl」および「hp」の0.05を超えるため、要約では、変数「am」の値に寄与することは重要ではないと考えます。 この回帰モデルでは、重み（wt）のみが「am」値に影響します。
R-正規分布
独立したソースからのデータのランダムな収集では、通常、データの分布は正常であることが観察されています。 つまり、水平軸の変数の値と垂直軸の値のカウントを使用してグラフをプロットすると、釣鐘型の曲線が得られます。 曲線の中心は、データセットの平均を表します。 グラフでは、値の50％が平均の左側にあり、残りの50％がグラフの右側にあります。 これは、統計では正規分布と呼ばれます。
Rには正規分布を生成する組み込み関数が4つあります。 以下に説明します。
dnorm(x, mean, sd)
pnorm(x, mean, sd)
qnorm(p, mean, sd)
rnorm(n, mean, sd)以下は、上記の機能で使用されるパラメータの説明です-
- x は数値のベクトルです。
- p は確率のベクトルです。
- n は観測数（サンプルサイズ）です。
- mean は、サンプルデータの平均値です。 デフォルト値はゼロです。
- sd は標準偏差です。 デフォルト値は1です。
dnorm（）
この関数は、与えられた平均と標準偏差の各点での確率分布の高さを与えます。
# Create a sequence of numbers between -10 and 10 incrementing by 0.1.
x <- seq(-10, 10, by = .1)
# Choose the mean as 2.5 and standard deviation as 0.5.
y <- dnorm(x, mean = 2.5, sd = 0.5)
# Give the chart file a name.
png(file = "dnorm.png")
plot(x,y)
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
pnorm（）
この関数は、正規分布された乱数が特定の数値よりも小さくなる確率を与えます。 「累積分布関数」とも呼ばれます。
# Create a sequence of numbers between -10 and 10 incrementing by 0.2.
x <- seq(-10,10,by = .2)
# Choose the mean as 2.5 and standard deviation as 2.
y <- pnorm(x, mean = 2.5, sd = 2)
# Give the chart file a name.
png(file = "pnorm.png")
# Plot the graph.
plot(x,y)
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
qnorm（）
この関数は、確率値を受け取り、累積値が確率値と一致する数値を提供します。
# Create a sequence of probability values incrementing by 0.02.
x <- seq(0, 1, by = 0.02)
# Choose the mean as 2 and standard deviation as 3.
y <- qnorm(x, mean = 2, sd = 1)
# Give the chart file a name.
png(file = "qnorm.png")
# Plot the graph.
plot(x,y)
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
rnorm（）
この関数は、分布が正規の乱数を生成するために使用されます。 サンプルサイズを入力として受け取り、その数の乱数を生成します。 ヒストグラムを作成して、生成された数値の分布を示します。
# Create a sample of 50 numbers which are normally distributed.
y <- rnorm(50)
# Give the chart file a name.
png(file = "rnorm.png")
# Plot the histogram for this sample.
hist(y, main = "Normal DIstribution")
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
R-二項分布
二項分布モデルは、一連の実験で可能な結果が2つしかないイベントの成功確率を見つけることを扱います。 たとえば、コインを投げると、常に頭または尾になります。 コインを10回繰り返し投げることで正確に3つの頭を見つける確率は、二項分布の間に推定されます。
Rには、2項分布を生成する4つの組み込み関数があります。 以下に説明します。
dbinom(x, size, prob)
pbinom(x, size, prob)
qbinom(p, size, prob)
rbinom(n, size, prob)以下は、使用されるパラメータの説明です-
- x は数値のベクトルです。
- p は確率のベクトルです。
- n は観測数です。
- *サイズ*は試行回数です。
- prob は、各試行の成功確率です。
dbinom（）
この関数は、各点の確率密度分布を提供します。
# Create a sample of 50 numbers which are incremented by 1.
x <- seq(0,50,by = 1)
# Create the binomial distribution.
y <- dbinom(x,50,0.5)
# Give the chart file a name.
png(file = "dbinom.png")
# Plot the graph for this sample.
plot(x,y)
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
pbinom（）
この関数は、イベントの累積確率を提供します。 これは、確率を表す単一の値です。
# Probability of getting 26 or less heads from a 51 tosses of a coin.
x <- pbinom(26,51,0.5)
print(x)上記のコードを実行すると、次の結果が生成されます-
[1] 0.610116qbinom（）
この関数は、確率値を受け取り、累積値が確率値と一致する数値を提供します。
# How many heads will have a probability of 0.25 will come out when a coin
# is tossed 51 times.
x <- qbinom(0.25,51,1/2)
print(x)上記のコードを実行すると、次の結果が生成されます-
[1] 23rbinom（）
この関数は、指定されたサンプルから指定された確率の必要な数の乱数値を生成します。
# Find 8 random values from a sample of 150 with probability of 0.4.
x <- rbinom(8,150,.4)
print(x)上記のコードを実行すると、次の結果が生成されます-
[1] 58 61 59 66 55 60 61 67R-ポアソン回帰
ポアソン回帰には、応答変数が小数ではなくカウントの形式である回帰モデルが含まれます。 たとえば、サッカーの試合シリーズでの出生数または勝利数のカウント。 また、応答変数の値はポアソン分布に従います。
ポアソン回帰の一般的な数学方程式は-
log(y) = a + b1x1 + b2x2 + bnxn.....以下は、使用されるパラメータの説明です-
- y は応答変数です。
- a および b は数値係数です。
- x は予測変数です。
ポアソン回帰モデルの作成に使用される関数は* glm（）*関数です。
構文
ポアソン回帰の* glm（）*関数の基本的な構文は次のとおりです-
glm(formula,data,family)以下は、上記の機能で使用されるパラメータの説明です-
- *式*は、変数間の関係を表す記号です。
- data は、これらの変数の値を提供するデータセットです。
- family は、モデルの詳細を指定するRオブジェクトです。 ロジスティック回帰の値は「ポアソン」です。
例
ウールのタイプ（AまたはB）と張力（低、中、または高）が織機ごとの経糸破断の数に与える影響を記述する組み込みデータセット「経糸破断」があります。 「ブレーク」を、ブレークの数のカウントである応答変数として考えてみましょう。 ウールの「タイプ」と「テンション」は、予測変数として使用されます。
- 入力データ *
input <- warpbreaks
print(head(input))上記のコードを実行すると、次の結果が生成されます-
breaks wool tension
1 26 A L
2 30 A L
3 54 A L
4 25 A L
5 70 A L
6 52 A L回帰モデルを作成する
output <-glm(formula = breaks ~ wool+tension, data = warpbreaks,
family = poisson)
print(summary(output))上記のコードを実行すると、次の結果が生成されます-
Call:
glm(formula = breaks ~ wool + tension, family = poisson, data = warpbreaks)
Deviance Residuals:
Min 1Q Median 3Q Max
-3.6871 -1.6503 -0.4269 1.1902 4.2616
Coefficients:
Estimate Std. Error z value Pr(>|z|)
(Intercept) 3.69196 0.04541 81.302 < 2e-16* **
woolB -0.20599 0.05157 -3.994 6.49e-05 ***
tensionM -0.32132 0.06027 -5.332 9.73e-08 ***
tensionH -0.51849 0.06396 -8.107 5.21e-16 ***
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
(Dispersion parameter for poisson family taken to be 1)
Null deviance: 297.37 on 53 degrees of freedom
Residual deviance: 210.39 on 50 degrees of freedom
AIC: 493.06
Number of Fisher Scoring iterations: 4要約では、応答変数に対する予測変数の影響を考慮するために、最後の列のp値が0.05未満になるようにします。 ご覧のように、張力タイプMおよびHのウールタイプBは、破断回数に影響を与えます。
R-共分散分析
回帰分析を使用して、予測変数の変動が応答変数に与える影響を記述するモデルを作成します。 Yes/NoやMale/Femaleなどの値を持つカテゴリ変数がある場合、時々 単純回帰分析では、カテゴリー変数の各値に対して複数の結果が得られます。 このようなシナリオでは、予測変数と一緒に使用し、カテゴリ変数の各レベルの回帰直線を比較することにより、カテゴリ変数の効果を調べることができます。 このような分析は、 ANCOVA とも呼ばれる Analysis of Covariance と呼ばれます。
例
Rに組み込まれたデータセットmtcarsについて考えます。 その中で、フィールド「am」は伝送のタイプ（自動または手動）を表していることがわかります。 値0および1のカテゴリ変数です。 馬力（ "hp"）の値に加えて、車のガロンあたりのマイル値（mpg）もそれに依存します。
「mpg」と「hp」の間の回帰に対する「am」の値の影響を研究します。 これは、* aov（）関数の後に anova（）*関数を使用して、重回帰を比較することにより行われます。
入力データ
データセットmtcarsからフィールド「mpg」、「hp」、および「am」を含むデータフレームを作成します。 ここでは、応答変数として「mpg」、予測変数として「hp」、カテゴリ変数として「am」を使用します。
input <- mtcars[,c("am","mpg","hp")]
print(head(input))上記のコードを実行すると、次の結果が生成されます-
am mpg hp
Mazda RX4 1 21.0 110
Mazda RX4 Wag 1 21.0 110
Datsun 710 1 22.8 93
Hornet 4 Drive 0 21.4 110
Hornet Sportabout 0 18.7 175
Valiant 0 18.1 105ANCOVA分析
「am」と「hp」の間の相互作用を考慮して、予測変数として「hp」、応答変数として「mpg」を使用する回帰モデルを作成します。
カテゴリ変数と予測変数の間の相互作用があるモデル
# Get the dataset.
input <- mtcars
# Create the regression model.
result <- aov(mpg~hp*am,data = input)
print(summary(result))上記のコードを実行すると、次の結果が生成されます-
Df Sum Sq Mean Sq F value Pr(>F)
hp 1 678.4 678.4 77.391 1.50e-09 ***
am 1 202.2 202.2 23.072 4.75e-05 ***
hp:am 1 0.0 0.0 0.001 0.981
Residuals 28 245.4 8.8
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1この結果は、両方の場合のp値が0.05未満であるため、馬力と伝達タイプの両方がガロンあたりのマイル数に大きな影響を与えることを示しています。 ただし、p値が0.05を超えるため、これら2つの変数間の相互作用は重要ではありません。
カテゴリ変数と予測変数間の相互作用のないモデル
# Get the dataset.
input <- mtcars
# Create the regression model.
result <- aov(mpg~hp+am,data = input)
print(summary(result))上記のコードを実行すると、次の結果が生成されます-
Df Sum Sq Mean Sq F value Pr(>F)
hp 1 678.4 678.4 80.15 7.63e-10 ***
am 1 202.2 202.2 23.89 3.46e-05 ***
Residuals 29 245.4 8.5
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1この結果は、両方の場合のp値が0.05未満であるため、馬力と伝達タイプの両方がガロンあたりのマイル数に大きな影響を与えることを示しています。
2つのモデルの比較
ここで、2つのモデルを比較して、変数の相互作用が本当に重要でないかどうかを結論付けることができます。 このために、* anova（）*関数を使用します。
# Get the dataset.
input <- mtcars
# Create the regression models.
result1 <- aov(mpg~hp*am,data = input)
result2 <- aov(mpg~hp+am,data = input)
# Compare the two models.
print(anova(result1,result2))上記のコードを実行すると、次の結果が生成されます-
Model 1: mpg ~ hp * am
Model 2: mpg ~ hp + am
Res.Df RSS Df Sum of Sq F Pr(>F)
1 28 245.43
2 29 245.44 -1 -0.0052515 6e-04 0.9806p値が0.05より大きいため、馬力と伝達タイプの相互作用は重要ではないと結論付けます。 したがって、ガロンあたりの走行距離は、自動および手動変速モードの両方で、同様に自動車の馬力に依存します。
R-時系列分析
時系列は、各データポイントがタイムスタンプに関連付けられている一連のデータポイントです。 簡単な例は、特定の日のさまざまな時点での株式市場の株価です。 別の例は、1年の異なる月の地域の降雨量です。 R言語では、多くの関数を使用して、時系列データを作成、操作、およびプロットします。 時系列のデータは、*時系列オブジェクト*と呼ばれるRオブジェクトに保存されます。 また、ベクトルまたはデータフレームのようなRデータオブジェクトでもあります。
時系列オブジェクトは、* ts（）*関数を使用して作成されます。
構文
時系列分析の* ts（）*関数の基本的な構文は次のとおりです-
timeseries.object.name <- ts(data, start, end, frequency)以下は、使用されるパラメータの説明です-
- data は、時系列で使用される値を含むベクトルまたは行列です。
- start は、時系列の最初の観測の開始時間を指定します。
- end は、時系列の最後の観測の終了時刻を指定します。
- frequency は、単位時間あたりの観測数を指定します。
パラメーター「data」を除き、他のすべてのパラメーターはオプションです。
例
2012年1月から始まる場所の年間降雨量の詳細を考慮してください。 12か月間のR時系列オブジェクトを作成し、プロットします。
# Get the data points in form of a R vector.
rainfall <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)
# Convert it to a time series object.
rainfall.timeseries <- ts(rainfall,start = c(2012,1),frequency = 12)
# Print the timeseries data.
print(rainfall.timeseries)
# Give the chart file a name.
png(file = "rainfall.png")
# Plot a graph of the time series.
plot(rainfall.timeseries)
# Save the file.
dev.off()上記のコードを実行すると、次の結果とグラフが生成されます-
Jan Feb Mar Apr May Jun Jul Aug Sep
2012 799.0 1174.8 865.1 1334.6 635.4 918.5 685.5 998.6 784.2
Oct Nov Dec
2012 985.0 882.8 1071.0時系列チャート-
異なる時間間隔
ts（）関数の frequency パラメーターの値は、データポイントが測定される時間間隔を決定します。 12の値は、時系列が12か月であることを示します。 他の値とその意味は以下のとおりです-
- frequency = 12 は、1年の各月のデータポイントを固定します。
- frequency = 4 は、1年の各四半期のデータポイントを固定します。
- frequency = 6 は、1時間の10分ごとにデータポイントを固定します。
- frequency = 24 6 *は、1日の10分ごとにデータポイントを固定します。
複数の時系列
両方の系列を行列に結合することにより、1つのチャートに複数の時系列をプロットできます。
# Get the data points in form of a R vector.
rainfall1 <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)
rainfall2 <-
c(655,1306.9,1323.4,1172.2,562.2,824,822.4,1265.5,799.6,1105.6,1106.7,1337.8)
# Convert them to a matrix.
combined.rainfall <- matrix(c(rainfall1,rainfall2),nrow = 12)
# Convert it to a time series object.
rainfall.timeseries <- ts(combined.rainfall,start = c(2012,1),frequency = 12)
# Print the timeseries data.
print(rainfall.timeseries)
# Give the chart file a name.
png(file = "rainfall_combined.png")
# Plot a graph of the time series.
plot(rainfall.timeseries, main = "Multiple Time Series")
# Save the file.
dev.off()上記のコードを実行すると、次の結果とグラフが生成されます-
Series 1 Series 2
Jan 2012 799.0 655.0
Feb 2012 1174.8 1306.9
Mar 2012 865.1 1323.4
Apr 2012 1334.6 1172.2
May 2012 635.4 562.2
Jun 2012 918.5 824.0
Jul 2012 685.5 822.4
Aug 2012 998.6 1265.5
Sep 2012 784.2 799.6
Oct 2012 985.0 1105.6
Nov 2012 882.8 1106.7
Dec 2012 1071.0 1337.8複数時系列チャート-
R-非線形最小二乗
回帰分析のために実世界のデータをモデル化するとき、モデルの方程式が線形グラフを与える線形方程式であるということはめったにないことがわかります。 ほとんどの場合、実世界のデータのモデルの方程式には、3の指数やsin関数などの高度な数学関数が含まれます。 このようなシナリオでは、モデルのプロットは直線ではなく曲線を示します。 線形回帰と非線形回帰の両方の目標は、モデルのパラメーターの値を調整して、データに最も近い直線または曲線を見つけることです。 これらの値を見つけると、応答変数を高い精度で推定できます。
最小二乗回帰では、回帰曲線からの異なる点の垂直距離の平方の合計が最小化される回帰モデルを確立します。 通常、定義済みのモデルから始めて、係数の値を想定します。 次に、Rの* nls（）*関数を適用して、信頼区間とともにより正確な値を取得します。
構文
Rで非線形最小二乗検定を作成するための基本的な構文は次のとおりです-
nls(formula, data, start)以下は、使用されるパラメータの説明です-
- *式*は、変数とパラメータを含む非線形モデル式です。
- data は、式の変数を評価するために使用されるデータフレームです。
- start は、名前付きリストまたは開始推定の名前付き数値ベクトルです。
例
係数の初期値を仮定した非線形モデルを検討します。 次に、これらの値がモデルにどれだけうまく反映されているかを判断できるように、これらの想定値の信頼区間を確認します。
だから、この目的のために以下の方程式を考えてみましょう-
a = b1*x^2+b2初期係数を1と3とし、これらの値をnls（）関数に適合させてみましょう。
xvalues <- c(1.6,2.1,2,2.23,3.71,3.25,3.4,3.86,1.19,2.21)
yvalues <- c(5.19,7.43,6.94,8.11,18.75,14.88,16.06,19.12,3.21,7.58)
# Give the chart file a name.
png(file = "nls.png")
# Plot these values.
plot(xvalues,yvalues)
# Take the assumed values and fit into the model.
model <- nls(yvalues ~ b1*xvalues^2+b2,start = list(b1 = 1,b2 = 3))
# Plot the chart with new data by fitting it to a prediction from 100 data points.
new.data <- data.frame(xvalues = seq(min(xvalues),max(xvalues),len = 100))
lines(new.data$xvalues,predict(model,newdata = new.data))
# Save the file.
dev.off()
# Get the sum of the squared residuals.
print(sum(resid(model)^2))
# Get the confidence intervals on the chosen values of the coefficients.
print(confint(model))上記のコードを実行すると、次の結果が生成されます-
[1] 1.081935
Waiting for profiling to be done...
2.5% 97.5%
b1 1.137708 1.253135
b2 1.497364 2.496484b1の値は1に近く、b2の値は3ではなく2に近いと結論付けることができます。
R-決定木
デシジョンツリーは、選択肢とその結果をツリー形式で表すグラフです。 グラフのノードはイベントまたは選択を表し、グラフのエッジは決定ルールまたは条件を表します。 Rを使用した機械学習およびデータマイニングアプリケーションで主に使用されます。
意思決定要素の使用例は、電子メールをスパムまたはスパムではないと予測する、腫瘍の癌を予測する、またはこれらのそれぞれの要因に基づいて融資を良いまたは悪い信用リスクとして予測するなどです。 一般に、モデルはトレーニングデータとも呼ばれる観測データで作成されます。 次に、検証データのセットを使用して、モデルを検証および改善します。 Rには、決定木の作成と視覚化に使用されるパッケージがあります。 新しい予測変数のセットでは、このモデルを使用して、データのカテゴリ（yes/no、spam/not spam）の決定に到達します。
Rパッケージ "party" は、決定木を作成するために使用されます。
Rパッケージをインストールする
Rコンソールで以下のコマンドを使用して、パッケージをインストールします。 また、依存パッケージがある場合はインストールする必要があります。
install.packages("party")パッケージ「party」には、決定ツリーの作成と分析に使用される関数* ctree（）*が含まれています。
構文
Rで決定木を作成するための基本的な構文は次のとおりです-
ctree(formula, data)以下は、使用されるパラメータの説明です-
- *式*は、予測変数と応答変数を記述する式です。
- data は、使用されるデータセットの名前です。
入力データ
*readingSkills* という名前のR組み込みデータセットを使用して、意思決定ツリーを作成します。 変数 "age"、 "shoesize"、 "score"がわかっている場合、およびその人がネイティブスピーカーであるかどうかを知っている場合、それは誰かのreadingSkillsのスコアを表します。これがサンプルデータです。
# Load the party package. It will automatically load other
# dependent packages.
library(party)
# Print some records from data set readingSkills.
print(head(readingSkills))上記のコードを実行すると、次の結果とグラフが生成されます-
nativeSpeaker age shoeSize score
1 yes 5 24.83189 32.29385
2 yes 6 25.95238 36.63105
3 no 11 30.42170 49.60593
4 yes 7 28.66450 40.28456
5 yes 11 31.88207 55.46085
6 yes 10 30.07843 52.83124
Loading required package: methods
Loading required package: grid
...............................
...............................例
- ctree（）*関数を使用して決定木を作成し、グラフを表示します。
# Load the party package. It will automatically load other
# dependent packages.
library(party)
# Create the input data frame.
input.dat <- readingSkills[c(1:105),]
# Give the chart file a name.
png(file = "decision_tree.png")
# Create the tree.
output.tree <- ctree(
nativeSpeaker ~ age + shoeSize + score,
data = input.dat)
# Plot the tree.
plot(output.tree)
# Save the file.
dev.off()上記のコードを実行すると、次の結果が生成されます-
null device
1
Loading required package: methods
Loading required package: grid
Loading required package: mvtnorm
Loading required package: modeltools
Loading required package: stats4
Loading required package: strucchange
Loading required package: zoo
Attaching package: ‘zoo’
The following objects are masked from ‘package:base’:
as.Date, as.Date.numeric
Loading required package: sandwich結論
上記の決定ツリーから、readingSkillsスコアが38.3未満で、年齢が6歳を超える人はネイティブスピーカーではないと結論付けることができます。
R-ランダムフォレスト
ランダムフォレストアプローチでは、多数の決定木が作成されます。 すべての観測は、すべての決定ツリーに送られます。 各観測の最も一般的な結果が最終出力として使用されます。 新しい観測がすべてのツリーに入力され、各分類モデルに対して多数決が行われます。
ツリーの構築中に使用されなかったケースのエラー推定が行われます。 これは* OOB（Out-of-bag）*エラー推定値と呼ばれ、パーセンテージで示されます。
Rパッケージ "randomForest" は、ランダムフォレストを作成するために使用されます。
Rパッケージをインストールする
Rコンソールで以下のコマンドを使用して、パッケージをインストールします。 また、依存パッケージがある場合はインストールする必要があります。
install.packages("randomForest)パッケージ「randomForest」には、ランダムフォレストの作成と分析に使用される関数* randomForest（）*が含まれています。
構文
Rでランダムフォレストを作成するための基本的な構文は次のとおりです-
randomForest(formula, data)以下は、使用されるパラメータの説明です-
- *式*は、予測変数と応答変数を記述する式です。
- data は、使用されるデータセットの名前です。
入力データ
readingSkillsという名前のR組み込みデータセットを使用して、意思決定ツリーを作成します。 変数 "age"、 "shoesize"、 "score"がわかっている場合、およびその人がネイティブスピーカーかどうかを知っている場合、その人のreadingSkillsのスコアを示します。
これがサンプルデータです。
# Load the party package. It will automatically load other
# required packages.
library(party)
# Print some records from data set readingSkills.
print(head(readingSkills))上記のコードを実行すると、次の結果とグラフが生成されます-
nativeSpeaker age shoeSize score
1 yes 5 24.83189 32.29385
2 yes 6 25.95238 36.63105
3 no 11 30.42170 49.60593
4 yes 7 28.66450 40.28456
5 yes 11 31.88207 55.46085
6 yes 10 30.07843 52.83124
Loading required package: methods
Loading required package: grid
...............................
...............................例
- randomForest（）*関数を使用して決定木を作成し、グラフを表示します。
# Load the party package. It will automatically load other
# required packages.
library(party)
library(randomForest)
# Create the forest.
output.forest <- randomForest(nativeSpeaker ~ age + shoeSize + score,
data = readingSkills)
# View the forest results.
print(output.forest)
# Importance of each predictor.
print(importance(fit,type = 2))上記のコードを実行すると、次の結果が生成されます-
Call:
randomForest(formula = nativeSpeaker ~ age + shoeSize + score,
data = readingSkills)
Type of random forest: classification
Number of trees: 500
No. of variables tried at each split: 1
OOB estimate of error rate: 1%
Confusion matrix:
no yes class.error
no 99 1 0.01
yes 1 99 0.01
MeanDecreaseGini
age 13.95406
shoeSize 18.91006
score 56.73051結論
上記のランダムフォレストから、誰かがネイティブスピーカーかどうかを決定する重要な要因はシューサイズとスコアであると結論付けることができます。 また、モデルには1％の誤差しかないため、99％の精度で予測できます。
R-生存分析
生存分析では、特定のイベントが発生する時間を予測します。 また、故障時間分析または死亡までの時間の分析としても知られています。 たとえば、がん患者の生存日数を予測したり、機械システムが故障する時間を予測したりします。
*survival* という名前のRパッケージは、生存分析の実行に使用されます。 このパッケージには、入力データをRフォーミュラとして受け取り、分析用に選択された変数の中で生存オブジェクトを作成する関数* Surv（）*が含まれています。 次に、関数* survfit（）*を使用して、分析用のプロットを作成します。パッケージをインストール
install.packages("survival")構文
Rで生存分析を作成するための基本的な構文は次のとおりです-
Surv(time,event)
survfit(formula)以下は、使用されるパラメータの説明です-
- time は、イベントが発生するまでのフォローアップ時間です。
- event は、予想されるイベントの発生状況を示します。
- *式*は、予測変数間の関係です。
例
上記でインストールされたサバイバルパッケージに存在する「pbc」という名前のデータセットを検討します。 肝臓の原発性胆汁性肝硬変（PBC）に罹患した人々に関する生存データポイントについて説明します。 データセットに存在する多くの列の中で、主にフィールド「時間」と「ステータス」に関心があります。 時間は、患者の登録から、肝移植を受ける患者または患者の死までの間のイベントの前の日数を表します。
# Load the library.
library("survival")
# Print first few rows.
print(head(pbc))上記のコードを実行すると、次の結果とグラフが生成されます-
id time status trt age sex ascites hepato spiders edema bili chol
1 1 400 2 1 58.76523 f 1 1 1 1.0 14.5 261
2 2 4500 0 1 56.44627 f 0 1 1 0.0 1.1 302
3 3 1012 2 1 70.07255 m 0 0 0 0.5 1.4 176
4 4 1925 2 1 54.74059 f 0 1 1 0.5 1.8 244
5 5 1504 1 2 38.10541 f 0 1 1 0.0 3.4 279
6 6 2503 2 2 66.25873 f 0 1 0 0.0 0.8 248
albumin copper alk.phos ast trig platelet protime stage
1 2.60 156 1718.0 137.95 172 190 12.2 4
2 4.14 54 7394.8 113.52 88 221 10.6 3
3 3.48 210 516.0 96.10 55 151 12.0 4
4 2.54 64 6121.8 60.63 92 183 10.3 4
5 3.53 143 671.0 113.15 72 136 10.9 3
6 3.98 50 944.0 93.00 63 NA 11.0 3上記のデータから、分析の時間とステータスを検討しています。
Surv（）およびsurvfit（）関数の適用
次に、上記のデータセットに* Surv（）*関数を適用し、傾向を示すプロットを作成します。
# Load the library.
library("survival")
# Create the survival object.
survfit(Surv(pbc$time,pbc$status == 2)~1)
# Give the chart file a name.
png(file = "survival.png")
# Plot the graph.
plot(survfit(Surv(pbc$time,pbc$status == 2)~1))
# Save the file.
dev.off()上記のコードを実行すると、次の結果とグラフが生成されます-
Call: survfit(formula = Surv(pbc$time, pbc$status == 2) ~ 1)
n events median 0.95LCL 0.95UCL
418 161 3395 3090 3853上記のグラフの傾向は、特定の日数の終わりに生存する確率を予測するのに役立ちます。
R-カイ二乗検定
- カイ2乗検定*は、2つのカテゴリ変数に有意な相関があるかどうかを判断する統計的手法です。 これらの変数は両方とも同じ母集団からのものでなければならず、-はい/いいえ、男性/女性、赤/緑などのようにカテゴリー的でなければなりません。
たとえば、人々のアイスクリーム購入パターンに関する観察結果を含むデータセットを構築し、人の性別と好みのアイスクリームのフレーバーとの相関をとることができます。 相関関係が見つかった場合、訪問する人々の性別を知ることにより、適切なフレーバーの在庫を計画できます。
構文
カイ二乗検定の実行に使用される関数は* chisq.test（）*です。
Rでカイ二乗検定を作成するための基本的な構文は次のとおりです-
chisq.test(data)以下は、使用されるパラメータの説明です-
- data は、観測の変数のカウント値を含むテーブル形式のデータです。
例
1993年の自動車のさまざまなモデルの販売を表す「MASS」ライブラリのCars93データを取得します。
library("MASS")
print(str(Cars93))上記のコードを実行すると、次の結果が生成されます-
'data.frame': 93 obs. of 27 variables:
$ Manufacturer : Factor w/32 levels "Acura","Audi",..: 1 1 2 2 3 4 4 4 4 5 ...
$ Model : Factor w/93 levels "100","190E","240",..: 49 56 9 1 6 24 54 74 73 35 ...
$ Type : Factor w/6 levels "Compact","Large",..: 4 3 1 3 3 3 2 2 3 2 ...
$ Min.Price : num 12.9 29.2 25.9 30.8 23.7 14.2 19.9 22.6 26.3 33 ...
$ Price : num 15.9 33.9 29.1 37.7 30 15.7 20.8 23.7 26.3 34.7 ...
$ Max.Price : num 18.8 38.7 32.3 44.6 36.2 17.3 21.7 24.9 26.3 36.3 ...
$ MPG.city : int 25 18 20 19 22 22 19 16 19 16 ...
$ MPG.highway : int 31 25 26 26 30 31 28 25 27 25 ...
$ AirBags : Factor w/3 levels "Driver & Passenger",..: 3 1 2 1 2 2 2 2 2 2 ...
$ DriveTrain : Factor w/3 levels "4WD","Front",..: 2 2 2 2 3 2 2 3 2 2 ...
$ Cylinders : Factor w/6 levels "3","4","5","6",..: 2 4 4 4 2 2 4 4 4 5 ...
$ EngineSize : num 1.8 3.2 2.8 2.8 3.5 2.2 3.8 5.7 3.8 4.9 ...
$ Horsepower : int 140 200 172 172 208 110 170 180 170 200 ...
$ RPM : int 6300 5500 5500 5500 5700 5200 4800 4000 4800 4100 ...
$ Rev.per.mile : int 2890 2335 2280 2535 2545 2565 1570 1320 1690 1510 ...
$ Man.trans.avail : Factor w/2 levels "No","Yes": 2 2 2 2 2 1 1 1 1 1 ...
$ Fuel.tank.capacity: num 13.2 18 16.9 21.1 21.1 16.4 18 23 18.8 18 ...
$ Passengers : int 5 5 5 6 4 6 6 6 5 6 ...
$ Length : int 177 195 180 193 186 189 200 216 198 206 ...
$ Wheelbase : int 102 115 102 106 109 105 111 116 108 114 ...
$ Width : int 68 71 67 70 69 69 74 78 73 73 ...
$ Turn.circle : int 37 38 37 37 39 41 42 45 41 43 ...
$ Rear.seat.room : num 26.5 30 28 31 27 28 30.5 30.5 26.5 35 ...
$ Luggage.room : int 11 15 14 17 13 16 17 21 14 18 ...
$ Weight : int 2705 3560 3375 3405 3640 2880 3470 4105 3495 3620 ...
$ Origin : Factor w/2 levels "USA","non-USA": 2 2 2 2 2 1 1 1 1 1 ...
$ Make : Factor w/93 levels "Acura Integra",..: 1 2 4 3 5 6 7 9 8 10 ...上記の結果は、データセットにカテゴリ変数と見なすことができる多くの因子変数があることを示しています。 このモデルでは、変数「AirBags」と「Type」を考慮します。 ここでは、販売されている車の種類と、所有しているエアバッグの種類との間に有意な相関関係を見つけることを目指しています。 相関関係が観察される場合、どのタイプの車がどのタイプのエアバッグでよりよく売れるかを推定できます。
# Load the library.
library("MASS")
# Create a data frame from the main data set.
car.data <- data.frame(Cars93$AirBags, Cars93$Type)
# Create a table with the needed variables.
car.data = table(Cars93$AirBags, Cars93$Type)
print(car.data)
# Perform the Chi-Square test.
print(chisq.test(car.data))上記のコードを実行すると、次の結果が生成されます-
Compact Large Midsize Small Sporty Van
Driver & Passenger 2 4 7 0 3 0
Driver only 9 7 11 5 8 3
None 5 0 4 16 3 6
Pearson's Chi-squared test
data: car.data
X-squared = 33.001, df = 10, p-value = 0.0002723
Warning message:
In chisq.test(car.data) : Chi-squared approximation may be incorrect結論
結果は、0.05未満のp値を示し、文字列相関を示します。 R-interview-questions
