만년필잉크의 데이터 분석 지식 저장소

패키지(Packages)란

오픈 소스인 R의 장점은 다른 사용자들이 만들어놓은 함수들을 쓸 수 있다는 것이다. 이 함수들의 모음을 패키지(Package)라고 하며, R을 이용하는 사람은 인터넷이 된다면, 언제, 어디서든지 이 패키지를 다운 받아서 사용할 수 있다.

• 패키지 공유는 CLAN(http://cran.r-project.org)의 'Packages'를 눌러서 어떤 패키지가 있는지 볼 수 있으며, 인터넷을 사용할 수 없는 환경에서 R을 써야하는 경우, 해당 싸이트에서 미리 사용할 패키지들을 다운받아올 수 있다. 
• R은 스크립트 언어(간략히 말하면, 어떤 기능을 쓰고자할 때, 그 기능을 처음부터 만들 필요 없이, 그 기능이 담긴 함수를 사용하면 되는 언어란 소리이다.)이며, 스크립트 언어로써의 기능을 잘 활용하려면, 상황에 맞게 내게 필요한 패키지를 찾는 능력이 필요하다.
• 각 패키지는 그 사용방법을 익히는데 도움을 주기 위한 내장 데이터셋을 가지고 있다.
• 패키지 설치 후 패키지 이름에 커서를 올린 상태에서 F1을 누르면 해당 패키지에 대한 자세한 정보를 얻을 수 있는 링크등으로 이동할 수 있다.

패키지 관련 함수

• available.packages("패키지 이름")
  : 해당 패키지가 CRAN에 등재되어 있는지 확인할 수 있는 함수.
• install.packages("패키지 이름")
  : 해당 해키지를 설치하는 방법.
  패키지는 한번 설치하면, 더 이상 설치하지 않아도 된다.
• library(패키지 이름)
  : 패키지를 사용하기 위해 가지고 온다.
  특정 패키지를 사용하고 싶을 때, 반드시 해당 코드를 한 번은 실행해 줘야한다.
• library(help = 패키지 이름)
  : 패키지에 대한 정보를 출력한다.
  (패키지의 라이센스, 버전, 제작자 등을 표시하고, 패키지 안에 들어 있는 함수등을 표기한다.)
• update.packages("패키지 이름")
  : 해당 패키지를 업데이트한다.
• updata.packages()
  : 모든 패키지를 업데이트한다.
• remove.packages("패키지 이름")
  : 해당 패키지를 삭제한다.
• remove.packages()
  : 모든 패키지를 삭제한다.
• 패키지이름::패키지의함수()
  : library() 함수를 사용하지 않고, 특정 패키지의 특정 함수를 사용한다.
  • 여러 패키지를 사용하는 경우, 패키지의 이름은 다르나, 함수가 동일한 경우가 종종 있다. 이 경우, 위 방법처럼 콜론을 2개 연달아 사용하면, 해당 함수가 어떤 패키지의 것인지를 쉽게 구분할 수 있다.
• data(package = .packages(all.available = TRUE))
  : 설치된 패키지의 모든 내장 데이터를 볼 수 있다.

# dplyr 패키지의 내장데이터를 확인해보자
data_list = data(package = .packages(all.available = TRUE))
data_list$results[data_list$results[,"Package"] == "dplyr", ]

##      Package LibPath                             Item               
## [1,] "dplyr" "C:/RBasicFolder/R/R-4.0.1/library" "band_instruments" 
## [2,] "dplyr" "C:/RBasicFolder/R/R-4.0.1/library" "band_instruments2"
## [3,] "dplyr" "C:/RBasicFolder/R/R-4.0.1/library" "band_members"     
## [4,] "dplyr" "C:/RBasicFolder/R/R-4.0.1/library" "starwars"         
## [5,] "dplyr" "C:/RBasicFolder/R/R-4.0.1/library" "storms"           
##      Title                
## [1,] "Band membership"    
## [2,] "Band membership"    
## [3,] "Band membership"    
## [4,] "Starwars characters"
## [5,] "Storm tracks data"

• 위 코드는 dplyr 패키지의 내장 데이터 목록을 행렬 형태로 가지고 온 것이다.
• Item은 내장 데이터의 이름이다.
• 위에서 "dplyr"만 다른 패키지의 이름으로 바꿔주면, 해당 패키지의 내장 데이터셋 목록을 가지고 올 수 있다.

수동으로 패키지 사용하기

• R을 효율적으로 사용할 수 있게 해주는 RStudio에는, 설치된 패키지, library로 import된 패키지, 패키지 업데이트 등을 쉽게 할 수 있는 창을 따로 제공하고 있다.

• 우측 하단의 Packages 버튼을 누르면, 현재 R에 어떤 패키지들이 설치 되어있고, 그 버전은 어떠한지를 구체적으로 볼 수 있다.
• 특정 패키지의 체크박스를 선택하고, Packages 바로 아래에 있는 Update 버튼을 누르면, 해당 패키지를 업데이트 할 수 있다.
• 패키지의 이름을 클릭하면 Help창으로 자동 이동되고, 해당 패키지에 어떤 함수가 있는지와 간략한 설명을 볼 수 있다. 또한 내가 궁금한 함수를 클릭하면, 보다 자세한 설명을 볼 수 있다.

패키지와 오류

1) 패키지의 의존성 문제

• 대부분의 패키지는 설치할 때, 큰 어려움이 없으나, 가끔 아주 강력한 패키지를 설치할 때, 오류가 걸리는 일이 종종 발생할 수 있다.
• 이는, 환경의 문제로 해당 패키지를 개발할 때, 들어간 소프트웨어가 해당 패키지를 설치하고자 하는 사람의 컴퓨터에 깔려 있지 않아서 발생하는 문제이다.
  (물론 전부 이 경우라고는 할 수 없지만, 대부분 이렇다!)
• 이 경우에는 설치하고자 하는 패키지의 정보를 확인하고, 이 패키지에 필요한 소프트웨어를 설치해주면 된다.
• R > CRAN > Korea(하단 아무 거나 클릭) > Packages > Table of available packages, sorted by name(이름 순 정렬) > ctrl + F로 문제 있는 패키지 검색 후 클릭 > SystemRequirements 옆에 있는 내용 확인
• SystemRequirements 에 있는 소프트웨어가 설치되어야만 해당 패키지를 정상적으로 사용할 수 있다.
• 추가로 에러 문구를 자세히 읽어보고, 구글링을 생활화하자!
  
  • 위에서 말한 소프트웨어 설치가 또 쉽지만은 않다. 그러므로, 해당 패키지 설치 방법을 구글에서 검색해보는 것이 베스트다.(이 고통을 나 혼자 겪은 것이 아니므로!)
  • R에서 당신이 겪은 대부분의 문제는 다른 사람도 겪었고, 개발자와의 소통 등을 통해서 대부분 해결된 문제이므로, 구글링을 하거나 Stack Overflow를 이용해서 해당 문제를 찾도록 해보자.

2) 패키지 업데이트의 문제

• 일반적으로 우리가 생각할 땐, 업데이트가 된 최신 버전이 가장 좋은 것이라고 생각하기가 쉬운데, 그 말이 R과 같은 오픈소스에서도 똑같이 통용되는 말은 아니다.
• 업데이트가 되면서 기존에 사용했던 함수에 새로운 파라미터가 주어졌을 수도 있고, 약간 기능이 바뀌었거나, 기존에 쓰고 있던 기능이 사라졌을 수도 있다!
  (물론 제작자가 상식적인 수준에서 변화를 주긴 했겠지만!)
• 당장 코드를 짤 땐, 큰 지장이 없을 수 있지만, 이미 길게 짜놓은 코드가 에러를 일으킬 가능성이 있으므로, 업데이트가 반드시 만능은 아니라고 생각하면 된다.
• 특히나, 지금까지 잘 사용했던 패키지가 돌연 업데이트를 멈추게 되는경우, R을 업데이트 했으나, R 패키지는 업데이트 되지 않아 서로 호환되지 않는 문제가 발생할 수도 있다.

3) 리눅스에서 R 패키지를 다운받는 경우 발생할 수 있는 문제.

• 리눅스에서 R을 사용하다보면 다음과 같은 문제가 종종 발생할 수 있다.

• ANTICONF ERROR Configuration failed because libmysqlclient was not found.......
• 위 오류에서 libmysqlclient 특히 "mysql" 이 부분은 설치하고자 하는 패키지 이름에 따라 바뀔 수 있다.
• 해당 오류는 말 그대로 내가 설치하고자 하는 패키지를 찾지 못한 문제인데, 해결 방법은 매우 단순하다.
• 리눅스 터미널에서 내가 사용하고 있는 리눅스 버전에 맞는 방법으로 설치하면 된다.
• 예를 들어, 내가 CentOS를 사용하고 있다면, CentOS용인 rpm을 이용하여 설치하면 된다.
• 구체적인 해결 방법은 다음과 같다.
• 리눅스 터미널 > yum install mysql-devel 입력 및 설치 > RStudio에서 패키지 설치 재실시

지금까지 R의 패키지에 대해 학습해보았다. 패키지는 설치에서 간간히 문제가 발생할 수는 있지만, 그 방법이 생각보다 단순하고, 패키지 관련 함수들도 install.packages()나 library() 같은 일부 함수를 제외하곤 거의 쓰이지 않기 때문에, 몇 번 쓰다보면 금새 익숙해질 것이다.

물론 몇몇 패키지를 설치하다가 오류가 나면 엄청 스트레스를 받긴 하겠지만, 그러한 문제 하나하나를 해결해나가다 보면, 어느새 실력이 부쩍 올라간 나 자신을 볼 수 있을 것이다.

이번 포스트는 여기서 마치도록 하겠다. 다음 포스트에선 R을 사용하는 데이터 분석가라면 거의 필수적으로 공부해야하는 패키지인 dplyr에 대해 공부해보도록 하자.

데이터 타입의 중요성은 아무리 강조해도 부족함이 없는데, R 초보자들이 주로 만들어내는 대부분의 오류는 input 데이터 타입과 output 데이터 타입이 서로 달라서 발생한다.

이번 포스트에선, 이 문제를 줄이기 위해 데이터 타입의 판별과 그 변환 방법에 대해 학습해보겠다. 

데이터 타입 판별과 타입 변환

• 데이터의 타입에 따라 사용자가 원하는 결과와 다른 결과가 출력될 수도 있다.
• 특히, 요인 변수가 숫자로 코딩돼 잇는 상태에서, 양적인 변수로 타입이 설정돼 있다면, 그래프 출력의 오류나, 분석 결과의 오류 등이 발생할 수 있으므로, 주의해야 한다.

1) 데이터 타입 판별 함수

2) 데이터 타입 변환 함수

지금까지 R의 데이터 타입 확인과 타입 변환 함수에 대해 알아보았다. 

다음 포스트에선 R에서 사용할 수 있는 함수들을 모아놓은 패키지에 대해 공부해보도록 하자.

지금까지 R의 기본적인 데이터 타입인 스칼라, 벡터, 행렬, 배열, 데이터프레임에 대해 공부해보았다.

이번 포스트에서는 R에서 기본적으로 제공하는 마지막 데이터 타입인 List에 대해 공부해보도록 하자.

리스트(List)

: 리스트는 R에 있는 데이터 타입 중 가장 독특한 데이터 타입이라고 할 수 있는데, 말 그대로 모든 데이터 타입을 담을 수 있는 데이터 타입이 바로 리스트이다.

• 리스트는 key, value 형태로 이루어져있다.
• 리스트는 모든 데이터 구조를 포함하는 데이터 구조이다.
• 여러 데이터 구조를 합하여 하나의 리스트를 만들 수 있다.
• 다른 언어의 Hash table이나 Dictionary에 해당한다.
• 서로 다른 변수 타입을 담을 수 있다.
• 리스트는 배열(Array), 데이터프레임(Data Frame)과 달리 들어가는 데이터들의 길이가 서로 같지 않아도 담을 수 있다.
• 리스트에 담긴 데이터마다 이름(key)을 부여할 수 있다.
• list()
  : 리스트를 만드는 함수

# 데이터프레임, 행렬, 벡터가 들어간 리스트를 만들어보자.
vt1 = c("민철", "재성", "기훈", "현승", "현택", "윤기" ,"재빈", "현희", "미선", "선화")
vt2 = c(70, 60, 50, 80, 90, 80, 65, 75, 90, 80)
vt3 = c(80, 70, 85, 65, 55, 70, 75, 80, 65, 75)
vt4 = c(75, 80, 90, 75, 85, 75, 80, 85, 80, 85)

df = data.frame("name" = vt1, "math" = vt2, "english" = vt3, "science" = vt4)

mat = matrix(seq(1, 12), nrow = 4)

vt = c("A", "B", "C", "D")

List = list(data1 = df, data2 = mat, data3 = vt)
List

## $data1
##    name math english science
## 1  민철   70      80      75
## 2  재성   60      70      80
## 3  기훈   50      85      90
## 4  현승   80      65      75
## 5  현택   90      55      85
## 6  윤기   80      70      75
## 7  재빈   65      75      80
## 8  현희   75      80      85
## 9  미선   90      65      80
## 10 선화   80      75      85
## 
## $data2
##      [,1] [,2] [,3]
## [1,]    1    5    9
## [2,]    2    6   10
## [3,]    3    7   11
## [4,]    4    8   12
## 
## $data3
## [1] "A" "B" "C" "D"

• 리스트 생성 시, 정한 이름으로 각 데이터의 key 값이 생성된 것을 알 수 있다.

리스트의 indexing

• 리스트의 특징은 리스트에 포함된 데이터들을 key라는 이름으로 불러올 수 있다는 것이다.
• 리스트의 indexing 방식은 지금까지와 약간 다르므로, 표로 정리해보겠다.

List$data1

##    name math english science
## 1  민철   70      80      75
## 2  재성   60      70      80
## 3  기훈   50      85      90
## 4  현승   80      65      75
## 5  현택   90      55      85
## 6  윤기   80      70      75
## 7  재빈   65      75      80
## 8  현희   75      80      85
## 9  미선   90      65      80
## 10 선화   80      75      85

List[2]

## $data2
##      [,1] [,2] [,3]
## [1,]    1    5    9
## [2,]    2    6   10
## [3,]    3    7   11
## [4,]    4    8   12

• 위 표에서 설명한 서브리스트가 바로 위 형태이다.
• list는 key와 value 2가지로 이루어져있으며, 위 List[2]의 결과를 보면, 이 역시 key와 value 2가지로 이루어진 list형임을 알 수 있다.

List[[2]]

##      [,1] [,2] [,3]
## [1,]    1    5    9
## [2,]    2    6   10
## [3,]    3    7   11
## [4,]    4    8   12

• [[n]]를 사용하면, 서브리스트가 아닌 그 데이터를 바로 가지고 온다.

리스트형에 대한 설명은 여기까지 하도록 하겠다.

설명이 매우 짧기 때문에 리스트형의 사용 용도가 그리 많지 않을 것으로 생각할 수 있는데, 길이가 다른 데이터 형을 담을 수 있다는 list형은 그 특징만으로도 사용처가 상당히 많다고 할 수 있다.

특히 R에 있는 lapply와 같은 리스트 형을 대상으로 한 함수나, 들어가는 데이터와 나오는 데이터의 길이가 불규칙한 경우, list형을 사용하면 쉽게 해결할 수 있다.

지금까지 R의 가장 기초가 되는 데이터 타입에 대해 공부해보았다.

데이터 타입은 R을 쓸 때, 기본 상식처럼 다룰 수 있어야하며, 데이터 타입을 잘 다루는 것이 R로 코드를 짤 때, 기초가 되는 부분이라고 할 수 있다.

다음 포스트에선 지금까지 공부한 타입과 그 판별, 변환 방법에 간략하게 정리를 해보도록 하겠다.

데이터 프레임(Data Frame)

지난 포스트에선 데이터프레임의 생성과 데이터프레임의 정보를 파악하는 법에 대하여 공부해보았다.

이번 포스트에선 데이터프레임에서 새로운 컬럼을 생성하는 방법과 데이터 프레임에 접근하는 법에 대해 공부해보도록 하자.

데이터 프레임 접근

• 데이터 프레임은 색인과 행과 열의 이름을 통해서 접근할 수 있다.
• df$colname
  : "데이터프레임$컬럼이름"을 이용하면 데이터프레임에서 원하는 데이터에 접근할 수 있다.
• df[r, c, drop = TRUE]
  : 데이터프레임 df의 r행, c열의 컬럼에 저장된 데이터를 가지고 올 수 있다.
  r과 c를 벡터로 지정하여 다수의 행과 컬럼을 동시에 가져올 수 있으며, 색인과 행 이름, 열 이름을 지정할 수도 있다. r과 c중 하나만 입력하는 경우, 예를 들어 c 하나만 넣은 경우엔 해당 열에 대한 모든 행 데이터를 가지고 온다.
  
  • r과 c중 하나만 불러오는 경우, 해당하는 행과 열 데이터만 해당 컬럼의 데이터 타입으로 가지고 오는데, 이러한 형 변환을 원하지 않는 경우엔 drop = FALSE로 지정하면 된다.
• 인덱싱 방법은 다음과 같다.
  • df$col1
    : 데이터 프레임 df에서 col1 컬럼을 가지고 온다.
  • df[1,]
    : 데이터 프레임 df에서 1번째 행을 가지고 온다.
  • df[c(1,3), 2]
    : 데이터 프레임 df에서 1, 3번째 행을 가지고 오고, 2번째 컬럼을 가지고 온다.
  • df[ , c(2:5)]
    : 데이터 프레임 df에서 2~5번까지 컬럼을 가지고 온다.
  • df[ , -c(2:5)] == df[ , c(-2:-5)]
    : 데이터 프레임 df에서 2~5번 컬럼을 제외하고 가지고 온다.
  • df[ , c("math", "science")]
    : 데이터 프레임 df에서 math와 science 컬럼만 가지고 온다.
• 위 인덱싱 방법말고도 다른 함수들을 조합해서 가지고 올 수는 있으나, 위 방법만으로도 충분하다.
• 위 인덱싱 방법들을 응용하여, 내가 가지고 오고 싶은 데이터만 가지고 와보자.

# 데이터 프레임에서 내가 원하는 값만 가지고 와보자.
vt1 = c("민철", "재성", "기훈", "현승", "현택", "윤기" ,"재빈", "현희", "미선", "선화")
vt2 = c(70, 60, 50, 80, 90, 80, 65, 75, 90, 80)
vt3 = c(80, 70, 85, 65, 55, 70, 75, 80, 65, 75)
vt4 = c(75, 80, 90, 75, 85, 75, 80, 85, 80, 85)

exam = data.frame("name" = vt1, "math" = vt2, "english" = vt3, "science" = vt4)

# exam에서 math컬럼만 가지고 오자.
exam$math

##  [1] 70 60 50 80 90 80 65 75 90 80

• indexing을 하는 경우, 데이터 타입이 바뀔 수 있으므로 주의해야한다.

# exam에서 1번째 행만 가지고 오자.
exam[1,]

##   name math english science
## 1 민철   70      80      75

# exam에서 1, 3행과 2번 컬럼만 가지고 오자.
exam[c(1,3),  2]

## [1] 70 50

# exam에서 2, 3, 4 행과 name, math 컬럼만 가지고 오자.
exam[c(2, 3, 4), c("name", "math")]

##   name math
## 2 재성   60
## 3 기훈   50
## 4 현승   80

# exam에서 3번째 컬럼만 제외하고 가지고 오자.
exam[, -c(3)]

##    name math science
## 1  민철   70      75
## 2  재성   60      80
## 3  기훈   50      90
## 4  현승   80      75
## 5  현택   90      85
## 6  윤기   80      75
## 7  재빈   65      80
## 8  현희   75      85
## 9  미선   90      80
## 10 선화   80      85

새로운 컬럼 추가

• 데이터 프레임에 새로운 컬럼(변수)를 추가하는 방법은 R 자체의 Base 함수를 쓰거나, dplyr과 같은 데이터 핸들링 패키지를 쓰는 방법 등이 있다.
• 이번 포스트에선 R의 Base 함수를 이용해서 새로운 컬럼을 추가해보자.
• 데이터 프레임은 indexing 방법이었던, "$변수이름"에 새로운 벡터를 추가하여 컬럼을 추가할 수 있다.

# 컬럼을 추가해보자.
vt1 = c("민철", "재성", "기훈", "현승", "현택", "윤기" ,"재빈", "현희", "미선", "선화")
vt2 = c(70, 60, 50, 80, 90, 80, 65, 75, 90, 80)
vt3 = c(80, 70, 85, 65, 55, 70, 75, 80, 65, 75)
vt4 = c(75, 80, 90, 75, 85, 75, 80, 85, 80, 85)

exam = data.frame("name" = vt1, "math" = vt2, "english" = vt3, "science" = vt4)

# Korean 이라는 과목을 추가해보자
exam$Korean <- c(70, 85, 90, 80, 65, 75, 80, 75, 85, 70)
head(exam)

##   name math english science Korean
## 1 민철   70      80      75     70
## 2 재성   60      70      80     85
## 3 기훈   50      85      90     90
## 4 현승   80      65      75     80
## 5 현택   90      55      85     65
## 6 윤기   80      70      75     75

# 총점을 추가해보자.
exam$total <- exam$math + exam$english + exam$science + exam$Korean
head(exam)

##   name math english science Korean total
## 1 민철   70      80      75     70   295
## 2 재성   60      70      80     85   295
## 3 기훈   50      85      90     90   315
## 4 현승   80      65      75     80   300
## 5 현택   90      55      85     65   295
## 6 윤기   80      70      75     75   300

# 평균점수를 구해보자.
exam$mean <- exam$total/4
head(exam)

##   name math english science Korean total mean
## 1 민철   70      80      75     70   295 73.75
## 2 재성   60      70      80     85   295 73.75
## 3 기훈   50      85      90     90   315 78.75
## 4 현승   80      65      75     80   300 75.00
## 5 현택   90      55      85     65   295 73.75
## 6 윤기   80      70      75     75   300 75.00

지금까지 데이터프레임에 대한 아주 기초적인 학습을 해보았다.

데이터프레임은 지금까지 다룬 내용으로만 끝내기엔, 활용처가 매우 많기 때문에, 다음 포스트인 list형에 대해 학습을 마치고 데이터 핸들링으로 가장 유명한 패키지인 dplyr에 대해 공부를 하면서, 보다 심도 깊게 다뤄보도록 하겠다.

데이터 프레임(Data Frame)

이번 포스트에선 R 데이터 타입의 꽃인 데이터프레임에 대해 학습해보겠다. 데이터프레임은 R에서 가장 중요한 자료형으로, 우리에게 익숙한 액셀의 스프레드시트와 같이 표 형태로 정리한 모습을 가지고 있다.

데이터프레임은 R에서 가장 많이 쓰이는 데이터 타입이며, 대용량의 데이터를 다루기엔 비효율적이라서 빅데이터 분석 시엔 fread를 비롯한 다른 데이터 타입을 사용하지만, 이 역시 기본적으로 데이터 프레임과 비슷한 형태를 가지고 있으며, 다루는 방법 역시 데이터 프레임과 비슷하다.

• 데이터 프레임은 행렬과 같은 모습을 하고 있지만, 행렬과 다르게 다양한 변수, 관측치(Observations), 범주(Category) 등을 표한하기 위해 특화되어 있다.
• 행렬은 하나의 데이터 타입밖에 사용하지 못하지만, 데이터 프레임은 여러 가지 데이터 타입을 혼용하여 사용할 수 있다.
• 데이터 프레임의 각 열(Column)별 행(Row)의 길이는 모두 동일하다.
• 데이터 프레임의 행(Row, Record)은 데이터의 대상이 되는 객체 하나하나 이다.
• 데이터 프레임의 열(Columns, Variable)은 데이터 대상이 되는 객체의 속성을 나타내는 값이다.
  각각의 Columns은 행렬과 달리 다양한 변수 타입을 가질 수 있다.

데이터프레임을 만들어보자

• 데이터 프레임은 벡터, 행렬로 만들 수 있다.
• 행렬을 그대로 데이터 프레임에 넣거나, 길이가 동일한 벡터들을 컬럼 하나하나에 배정하여 생성하면 된다.
• data.frame()
  : 데이터 프레임을 생성한다.
• 주요 Parameter
  : data.frame(stringsAsFactors: 문자열을 자동으로 요인(Factor)형으로 변환해준다.)
  • data.frame에서 중요한 Parameter는 stringsAsFactors말고는 딱히 없다. data.frame에서 다른 Parameter들에 대한 내용을 읽어보고자 한다면, data.frame 코드를 치고 F1을 눌러서 보도록 하자.
  • stringsAsFactors는 간단하지만, 상당히 중요한 Parameter로, 말 그대로 문자열을 요인(Factor)으로 바꿔주는 Parameter이다. 만약 string형인 열을 이용해서 새로운 변수를 만들어내거나, 특정 문자열을 분리해내는 작업을 하지 않는다면, 해당 Parameter를 TRUE로 두어 모두 Factor형으로 바꾸는 것이 유리하다.
  • 그러나, 문자열에 대하여 어떠한 조작을 하는 경우엔, Factor형으론 조작이 매우 힘드므로, 가능하다면 해당 Parameter를 FALSE로 두는 것을 추천한다.

1) 벡터를 이용해서 데이터프레임을 만들어보자.

# 벡터로 데이터프레임을 만들어보자
vt1 = c("민철", "재성", "기훈", "현승", "현택")
vt2 = c(70, 60, 50, 80, 90)
vt3 = c(80, 70, 85, 65, 55)

df1 = data.frame(vt1, vt2, vt3)
df1

##    vt1 vt2 vt3
## 1 민철  70  80
## 2 재성  60  70
## 3 기훈  50  85
## 4 현승  80  65
## 5 현택  90  55

• 데이터 프레임 안에 길이가 동일한 벡터를 넣어주면 된다.
• 길이가 다른 벡터를 함께 넣는 경우 에러가 뜨며 데이터프레임이 생성되지 않는다.
• 각 컬럼의 이름은 벡터의 이름으로 정해진다.

2) 행렬을 이용해서 데이터프레임을 만들어보자.

# 행렬로 데이터프레임을 만들어보자
vt = c("민철", "재성", "기훈", "현승", "현택", 70, 60, 50, 80, 90, 80, 70, 85, 65, 55)
mat = matrix(vt, ncol = 3, byrow = FALSE)

data.frame(mat)

##    X1  X2  X3
## 1 민철  70  80
## 2 재성  60  70
## 3 기훈  50  85
## 4 현승  80  65
## 5 현택  90  55

• 데이터 프레임 안에 행렬을 넣어주면 된다.
• 각 컬럼의 이름은 X1, X2, X3...와 같은 방식으로 생성된다.
• 행렬은 하나의 변수 타입만 가질 수 있으므로, 행렬을 데이터 프레임으로 바꾸는 경우, 하나의 속성만 가진 형태로 데이터프레임이 만들어진다.

str(data.frame(mat))

'data.frame':	5 obs. of  3 variables:
 $ X1: chr  "민철" "재성" "기훈" "현승" ...
 $ X2: chr  "70" "60" "50" "80" ...
 $ X3: chr  "80" "70" "85" "65" ...

• 그러니 되도록이면 행렬로 데이터프레임을 만들기보다는 벡터를 이용해서 만들도록 하자.
• 만약 행렬로 만들어야한다면, 데이터프레임 생성 후, 각 컬럼의 변수 타입을 모두 바꿔주도록 하자.

데이터 프레임 변수의 이름을 바꿔보자.

• 이번엔 데이터 프레임 컬럼의 이름을 바꿔보자.
• 데이터 프레임 컬럼 이름 변경은 2가지 방법이 있다.

1) 데이터 프레임 생성 시, 벡터의 이름을 설정해준다.

# 벡터로 데이터프레임을 만들어보자
vt1 = c("민철", "재성", "기훈", "현승", "현택")
vt2 = c(70, 60, 50, 80, 90)
vt3 = c(80, 70, 85, 65, 55)

data.frame("name" = vt1, "math" = vt2, "english" = vt3)

##   name math english
## 1 민철   70      80
## 2 재성   60      70
## 3 기훈   50      85
## 4 현승   80      65
## 5 현택   90      55

2) 생성된 데이터 프레임의 이름을 바꿔준다.

• colnames()
  : data의 column의 이름들을 가지고 온다.

# 변수명을 바꿔보자.
vt1 = c("민철", "재성", "기훈", "현승", "현택")
vt2 = c(70, 60, 50, 80, 90)
vt3 = c(80, 70, 85, 65, 55)

df = data.frame(vt1, vt2, vt3)
colnames(df)

## [1] "vt1" "vt2" "vt3"

• colnames(df)를 하면, dataframe의  column 이름들을 가지고 온다.

colnames(df) <- c("name", "math", "english")
df

• colnames(df)에 벡터로 새로운 컬럼의 이름을 부여해보자.

##   name math english
## 1 민철   70      80
## 2 재성   60      70
## 3 기훈   50      85
## 4 현승   80      65
## 5 현택   90      55

3) 행의 이름을 바꿔주자.

• 데이터프레임은 행을 index로 활용할 수 있으며, 행에 변수를 넣을 수도 있다.
• 단 행의 이름은 절대 중복되서는 안된다.
• 그러므로, ID를 만들어서 넣거나, 기존의 행 번호를 그대로 사용하도록 하자.
• rownames()
  : data의 행 이름들을 가지고 온다.

# 행의 이름을 바꿔보자
vt1 = c("민철", "재성", "기훈", "현승", "현택")
vt2 = c(70, 60, 50, 80, 90)
vt3 = c(80, 70, 85, 65, 55)

df = data.frame(vt1, vt2, vt3)
rownames(df)

## [1] "1" "2" "3" "4" "5"

# 데이터프레임의 vt1을 row의 이름으로 사용해보자
rownames(df) <- df[,1]

# 데이터프레임에서 첫번째 컬럼과 행의 이름이 동일하므로, 첫번째 컬럼은 제거해서 가지고 와보자.
df[,-1]

##      vt2 vt3
## 민철  70  80
## 재성  60  70
## 기훈  50  85
## 현승  80  65
## 현택  90  55

• 이번에 사용한 코드들을 보면, 행렬에서 다뤘던 indexing과 동일한 것을 볼 수 있다.
• 행렬도 데이터프레임처럼 행의 이름과 열의 이름을 동일한 방법으로 바꿀 수 있다.
• 데이터프레임의 Indexing에 대해선 다음 포스트에서 더 자세히 다뤄보도록 하겠다.

데이터 프레임의 정보를 살펴보자.

• 이번엔 데이터프레임의 기본적인 정보를 살펴보는 방법을 보자.
• str()
  : 데이터프레임의 차원과 각 열에 대한 정보 출력
• head()
  : 일반적인 데이터프레임은 매우 크므로, 모두 보는 것은 힘들다. head()를 사용하면, 맨 위에서 n개(기본값 6)의 행을 가지고 온다. 데이터프레임을 보고자 한다면, head()를 이용해서 보도록 하자.
• tail()
  : head()와 반대로 데이터프레임의 맨 아래에서 n개(기본값 6)의 행을 가지고 온다. tail()을 이용하면, 데이터프레임의 맨 아래 부분에 어떠한 특이사항이 있는지를 눈으로 쉽게 확인할 수 있다.
• summary()
  : 데이터프레임에 있는 변수별 기술통계량을 볼 수 있다.
  변수 타입이 연속형변수인 경우에는 최소값, 최대값, 사분위 수, 평균을 볼 수 있다.
  변수 타입이 문자형과 같은 범주형 변수인 경우에는 변수의 길이, Class, Mode 등을 볼 수 있다.
  (Mode는 R의 기본 배경이 된 언어인 S language와 호환성을 가진 언어로, 간단하게 말하면 과거 버전의 타입 분류 방법이라고 생각하면 된다. R을 사용할 땐, Class가 우선이라고 간략하게 생각하고, Class에만 신경 쓰도록 하자.)
• dim()
  : 데이터프레임의 차원별 길이를 볼 수 있다.
  데이터 프레임은 행과 열 2개의 차원으로 구성되어 있으며, dim() 함수를 이용하면 행의 수, 열의 수를 볼 수 있다.
• View()
  : 데이터프레임을 데이터 뷰어창에서 볼 수 있다.
  데이터프레임 뿐만 아니라 행렬, 벡터 등도 볼 수 있다.

# 데이터 프레임의 구조를 살펴보자.
vt1 = c("민철", "재성", "기훈", "현승", "현택", "윤기" ,"재빈", "현희", "미선", "선화")
vt2 = c(70, 60, 50, 80, 90, 80, 65, 75, 90, 80)
vt3 = c(80, 70, 85, 65, 55, 70, 75, 80, 65, 75)

df = data.frame("name" = vt1, "math" = vt2, "english" = vt3)
df

##    name math english
## 1  민철   70      80
## 2  재성   60      70
## 3  기훈   50      85
## 4  현승   80      65
## 5  현택   90      55
## 6  윤기   80      70
## 7  재빈   65      75
## 8  현희   75      80
## 9  미선   90      65
## 10 선화   80      75

# 데이터 프레임의 차원과 각 열에 대한 정보를 알아보자.
str(df)

## 'data.frame':    10 obs. of  3 variables:
##  $ name   : chr  "민철" "재성" "기훈" "현승" ...
##  $ math   : num  70 60 50 80 90 80 65 75 90 80
##  $ english: num  80 70 85 65 55 70 75 80 65 75

# 데이터 프레임의 위부터 n행까지 추출한다(기본값은 6).
head(df, n = 5)

##   name math english
## 1 민철   70      80
## 2 재성   60      70
## 3 기훈   50      85
## 4 현승   80      65
## 5 현택   90      55

# 데이터 프레임의 아래부터 n행까지 추출한다(기본값은 6).
tail(df, n = 5)

##    name math english
## 6  윤기   80      70
## 7  재빈   65      75
## 8  현희   75      80
## 9  미선   90      65
## 10 선화   80      75

# 변수별 요약통계량 출력
summary(df)

##      name                math          english     
##  Length:10          Min.   :50.00   Min.   :55.00  
##  Class :character   1st Qu.:66.25   1st Qu.:66.25  
##  Mode  :character   Median :77.50   Median :72.50  
##                     Mean   :74.00   Mean   :72.00  
##                     3rd Qu.:80.00   3rd Qu.:78.75  
##                     Max.   :90.00   Max.   :85.00

# 데이터 프레임의 차원별 길이 출력
dim(df)

## [1] 10  3

# 데이터 뷰어로 데이터 프레임을 보자.
View(df)

• View() 함수를 이용하는 경우, 데이터 프레임을 데이터 뷰어라는 새로운 창에서 크게 볼 수 있다.
• R에서 매우 큰 데이터 프레임을 head()나 tail()가 아닌 그 자체로 불러오는 경우, R이 뻗어버릴 수 도 있지만(너무 큰 데이터를 표현하면, 부하가 매우 크므로, 가능한 dataframe 이름만 쳐서 가지고 오는 행동은 하지 말자) View를 사용해서 데이터 뷰어에서 보면 R이 뻗지는 않는다.
  (물론, 데이터의 크기가 너무 크므로, 보는 것이 굉장히 불편하긴 하다.)

지금까지 데이터프레임을 만들고 데이터프레임의 기본적인 정보를 보는 법에 대해 학습해보았다.

다음 포스트에선 데이터프레임에 새로운 변수를 추가해보거나, Indexing 하는 방법 등을 공부해보자.

이번 포스트에선 배열(Array)에 대해 공부해보자.

배열(Array)

: 행렬이 2차원의 데이터라면 배열(Array)는 다차원의 데이터라고 할 수 있다. 예를 들어 2x3 차원의 데이터를 행렬로 표현한다면, 2x3x4 차원의 데이터는 배열(Array)로 표현한다.

• 간단히 말하자면 (NxM)행렬을 Z개 쌓아놓는다고 보면된다.
• 당연히 Z개 쌓여있는 행렬들의 형태(차원)은 모두 동일하다고 할 수 있다.
• array()
  : 배열을 만들 수 있다.
• 주요 Parameter
  : array(data, dim = c(행의 수, 열의 수, 행렬의 수), dimnames = list(c(행의 이름), c(열의 이름), c(행렬의 이름)))

# 배열을 만들어보자.
Vt = seq(from = 1, by = 2, length.out = 12*3)
Ar = array(Vt, dim = c(4, 3, 3), dimnames = list(c("r1", "r2", "r3", "r4"),c("c1", "c2", "c3"),c("M1", "M2", "M3")))
Ar

## , , M1
## 
##    c1 c2 c3
## r1  1  9 17
## r2  3 11 19
## r3  5 13 21
## r4  7 15 23
## 
## , , M2
## 
##    c1 c2 c3
## r1 25 33 41
## r2 27 35 43
## r3 29 37 45
## r4 31 39 47
## 
## , , M3
## 
##    c1 c2 c3
## r1 49 57 65
## r2 51 59 67
## r3 53 61 69
## r4 55 63 71

• 배열은 기본적으로 행렬이 한 열씩 채워가는 방식으로 생성된다.
• 배열 역시 행렬과 마찬가지로, 배열을 구성할 벡터의 원소 수가 배열에 필요한 원소 수보다 작은 경우, 벡터의 앞부분부터 행렬의 빈자리에 구성된다.

배열에서 원하는 데이터 가지고 오기.

• 배열에서 원하는 데이터를 가지고 오는 것은 행렬과 기본적으로 동일하며, 차원이 한 개 더 증가한 것과 같다.

Ar[,,"M2"]

##    c1 c2 c3
## r1 25 33 41
## r2 27 35 43
## r3 29 37 45
## r4 31 39 47

배열은 행렬을 다차원으로 담을 수 있는 데이터 타입으로, 전통적인 통계 분석에서는 그다지 필요가 없어보일 수 있다. 그리고, 동일한 2차원의 행렬에 대해서만 array에 적재할 수 있으므로, 모든 형태의 데이터 타입을 담을 수 있는 List에 비해 그 기능이 부족해보일 수 있다.

그러나, 반대로 말하자면 다차원 행렬을 적극적으로 사용해야하는 공학이나 요즘 핫한 빅데이터 분석에서는 array가 매우 유용한 데이터 타입이라고 할 수 있다. 꼭 숙지해놓고, 잘 활용해보도록 하자.

다음 포스트에서는 R 데이터 타입의 꽃인 데이터 프레임에 대해 학습해보도록 하자.

지금까지 행렬 생성과 행렬에 대한 기본적인 조작, 데이터 접근, 행렬 연산 등에 대해 학습해 보았다.

이번에는 포스트에선 역행렬, 가운데 행렬과 같은 약간 독특한 행렬들에 대해 학습해보자.

역행렬(Inverse Matrix)

• 역행렬은 행렬의 역수라고 할 수 있으며, 행렬 A와 곱했을 때 단위 행렬 E가 나오게 하는 행렬을 A의 역행렬이라고 한다.
• 역행렬은 정방행렬(n x n)에 대해서만 구할 수 있다. 장방행렬(n x m)에 대해서는 구할 수 없다.
• solve()
  : 수식 A %*% X = B에서 X인 행렬을 구한다. 즉, A와 행렬곱 하여 B가 만들어지게 하는 행렬 X를 구한다.
• 주요 Parameter
  : solve(A, B, ...)
  B의 자리를 공란으로 넣는다면, A의 역행렬을 구한다.

vt3 = c(4, 2, 3, 0, 1, 0, 2, 3, 0, 2, 1, 4, 0, 2, 1, 3)
mat3 = matrix(vt3, nrow = 4, byrow = TRUE)
mat3

##      [,1] [,2] [,3] [,4]
## [1,]    4    2    3    0
## [2,]    1    0    2    3
## [3,]    0    2    1    4
## [4,]    0    2    1    3

solve(mat3)

##             [,1]       [,2]  [,3]       [,4]
## [1,]  0.33333333 -0.3333333  2.00 -2.3333333
## [2,]  0.08333333 -0.3333333 -0.25  0.6666667
## [3,] -0.16666667  0.6666667 -2.50  2.6666667
## [4,]  0.00000000  0.0000000  1.00 -1.0000000

전치행렬(Transpose Matrix)

• R(기초) 행렬(Matrix)(2부)에서 잠깐 다뤘던 전치행렬에 대해서 다시 한번 정리하겠다.
• m*n 행렬의 행과 열을 서로 바꾼 n*m 행렬로 만든 것을 전치 행렬이라고 한다.
• 주대각선(Main Diagonal)을 기준으로 하여 뒤집은 것을 가리킨다.
  ※ (1,1), (2,2), (3,3).... 과 같이 행과 열의 값이 같은 행렬의 가운데 부분을 주대각선(대각성분)이라 한다.
• t()
  : 전치행렬로 만든다.

※ 대각성분(주대각선)인 (1,1), (2,2), (3,3)을 기준으로 뒤집은 것이 전치 행렬이다.

mat <- matrix(c(1:12), nrow = 4, byrow = TRUE)
mat

##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6
## [3,]    7    8    9
## [4,]   10   11   12

t(mat)

##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12

대칭행렬(Symmetric Matrix)

• 대각성분을 중심으로 대칭인 정방행렬(n*n)을 가리킨다.
• 대각성분을 중심으로 대칭이므로, 원래 행렬과 전치행렬은 동일하다.
• 대칭행렬을 만들고 싶다면, 일반 행렬을 생성하고, 상삼각행렬 혹은 하삼각행렬의 위치에 대하여, 그 전치행렬의 값을 덮어 씌우면 된다.
  (무슨 말인지 모르겠지만, 실습을 하며 천천히 따라와보면 이해하게 될 것이다.)

# 대칭행렬을 만들어보자
mat = matrix(c(1:16), nrow = 4, byrow = TRUE)
mat

##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## [3,]    9   10   11   12
## [4,]   13   14   15   16

•  c(1:16)으로 1~16까지 값이 들어간 벡터로, 정방행렬(4*4)을 만들었다.

# 하삼각행렬의 값들을 가져와보자
lower.tri(mat, diag = FALSE)

##       [,1]  [,2]  [,3]  [,4]
## [1,] FALSE FALSE FALSE FALSE
## [2,]  TRUE FALSE FALSE FALSE
## [3,]  TRUE  TRUE FALSE FALSE
## [4,]  TRUE  TRUE  TRUE FALSE

•  lower.tri()는 하삼각행렬을 만들 때 사용하는 함수로, 뒤에서 다시 한번 다루겠지만, 가운데 성분을 기준으로하여, 아랫쪽을 TRUE로 Masking한다.
  (상삼각행렬을 쓰는 경우엔, upper.tri()를 쓰면 되며, 방법은 동일하다.)
•  lower.tri()의 parameter인 diag는 대각성분을 포함할 것인지 여부이다.

mat[lower.tri(mat, diag = FALSE)]

## [1]  5  9 13 10 14 15

• 벡터, 행렬에서 Indexing을 할 때, 우리는 대괄호를 사용하여 가져왔었는데, 이 대괄호는 TRUE로 Masking된 값들을 가져오는 것이다.

# 전치행렬에 대한 하삼각행렬의 위치의 값을 본 행렬의 하삼각행렬 위치에 넣도록 하자.
mat[lower.tri(mat, diag = FALSE)] <- t(mat)[lower.tri(mat, diag = FALSE)]
mat

##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    2    6    7    8
## [3,]    3    7   11   12
## [4,]    4    8   12   16

• 조금 복잡해보이지만, 원리는 되게 단순하다.
• 대칭행렬은 대각성분을 중심으로 대칭인 행렬이고, 전치행렬은 대각성분을 중심으로 반전된 행렬이다.
• 즉, 원래의 행렬의 하삼각행렬(or 상삼각행렬)에 전치행렬의 하삼각행렬(or 상삼각행렬)의 위치의 값을 넣으면, 대칭행렬이 만들어지는 것이다.
• 이를 더 풀어서 써보면 가운데 성분 아래(하삼각행렬의 위치 = TRUE로 Masking 된 곳)에 가운데 성분 위의 값을 가운데 성분을 중심으로 뒤집어서(전치 행렬) 가운데 성분 아래에 그대로 넣었다고 생각하면 된다.

대각 행렬(Diagonal Matrix)

• 대각행렬은 대칭행렬과 비슷해보이지만, 생성 난이도는 보다 쉬운 행렬이다.
• 대각행렬은 정방행렬(n*n)에서 대각성분을 제외한 모든 값이 0인 경우를 말한다.
• diag()
  : 행렬의 대각성분을 가지고 오거나, 대각성분에 다른 값을 넣을 수 있게 해주는 함수, diag(Vector)를 하는 경우, 대각행렬이 생성된다.
• 항등행렬(Identity Matrix)는 대각성분이 1이고 나머지 원소는 0인 행렬이므로, 대각성분을 모두 1로 생성하면 된다.

# 대각행렬을 만들어보자.
diag(c(1:5))

##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    0    0    0    0
## [2,]    0    2    0    0    0
## [3,]    0    0    3    0    0
## [4,]    0    0    0    4    0
## [5,]    0    0    0    0    5

• 가운데 성분을 제외하고 모두 0인 대각행렬을 만들어보았다.

# 대각성분을 가지고 와보자
mat <- matrix(c(1:16), nrow = 4)
mat

##      [,1] [,2] [,3] [,4]
## [1,]    1    5    9   13
## [2,]    2    6   10   14
## [3,]    3    7   11   15
## [4,]    4    8   12   16

diag(mat)

## [1]  1  6 11 16

• diag() 함수를 이용하면, 행렬의 대각성분만 벡터로 가지고 올 수 있다.

# 대각성분의 원소를 모두 0으로 만들자
diag(mat) <- 0
mat

##      [,1] [,2] [,3] [,4]
## [1,]    0    5    9   13
## [2,]    2    0   10   14
## [3,]    3    7    0   15
## [4,]    4    8   12    0

• 행렬의 대각성분에 스칼라 값을 넣어서 대각성분이 0인 행렬을 만들어보았다.
• 대칭행렬 만들기와 대각성분을 0으로 만들기를 조합하여 코드를 짜면 대칭행렬이면서 대각성분이 0인 행렬을 만들 수 있다.

하삼각행렬(Lower Triangular Matrix)과 상삼각행렬(Upper Triangular Matrix)

• 하삼각행렬은 대각성분을 중심으로, 그 윗 부분이 모두 0인 정방행렬을 말한다.
• 상삼각행렬은 대각성분을 중심으로, 그 아랫 부분이 모두 0인 정방행렬을 말한다.
• lower.tri()
  : 행렬의 가운데 성분을 기점으로(가운데 성분 포함 가능), 아랫 부분을 TRUE로 Masking하는 함수
• upper.tri()
  : 행렬의 가운데 성분을 기점으로(가운데 성분 포함 가능), 윗 부분을 TRUE로 Masking하는 함수
• 상삼각행렬은 대각성분을 중심으로, 아랫 부분이 0이므로, lower.tri()함수를 이용해 대각성분 아래쪽을 indexing하여 0을 집어넣으면 된다.
• 하삼각행렬은 대각성분을 중심으로, 윗 부분이 0이므로, upper.tri()함수를 이용해 대각성분 위쪽을 indexing하여 0을 집어넣으면 된다.

# 상삼각행렬을 만들어보자.
mat = matrix(c(1:16), 4)
lower.tri(mat, diag = FALSE)

• diag = FALSE 로 Parameter를 부여하여, 가운데 성분은 Masking하지 않도록 하자.

##       [,1]  [,2]  [,3]  [,4]
## [1,] FALSE FALSE FALSE FALSE
## [2,]  TRUE FALSE FALSE FALSE
## [3,]  TRUE  TRUE FALSE FALSE
## [4,]  TRUE  TRUE  TRUE FALSE

mat[lower.tri(mat, diag = FALSE)] <- 0
mat

• 선택된 가운데 성분의 아랫부분에 0을 넣어서 상삼각행렬을 만들었다.

##      [,1] [,2] [,3] [,4]
## [1,]    1    5    9   13
## [2,]    0    6   10   14
## [3,]    0    0   11   15
## [4,]    0    0    0   16

# 하삼각행렬을 만들어보자.
mat = matrix(c(1:16), 4)
upper.tri(mat, diag = FALSE)

##       [,1]  [,2]  [,3]  [,4]
## [1,] FALSE  TRUE  TRUE  TRUE
## [2,] FALSE FALSE  TRUE  TRUE
## [3,] FALSE FALSE FALSE  TRUE
## [4,] FALSE FALSE FALSE FALSE

mat[upper.tri(mat, diag = FALSE)] <- 0
mat

##      [,1] [,2] [,3] [,4]
## [1,]    1    0    0    0
## [2,]    2    6    0    0
## [3,]    3    7   11    0
## [4,]    4    8   12   16

자, 지금까지 역행렬, 전치행렬, 대각행렬, 대칭행렬, 상삼각행렬, 하삼각행렬에 대해 알아보았다. 행렬은 이 것보다 훨씬 심도 깊은 분야기 때문에, R의 기초인 데이터 타입 공부에선 기본적으로 알아야하는 부분만 짚고 넘어가도록 하겠다.

다음 포스트에선 배열(Array)에 대해 학습해보도록 하겠다.

저번 포스트에선 행렬 생성과 행과 열의 이름 변경, 행렬의 정보 얻기 등을 공부해보았다.
이번 포스트에선 행렬 데이터 접근, 행렬의 연산에 대해 학습해보자.

행렬 데이터 접근하기

• 행렬은 색인 또는 행과 열의 이름을 통해서 접근할 수 있다.
• 행렬은 벡터와 같게 [] 대괄호를 이용해서 데이터에 접근한다.
• 단 행렬은 벡터와 다르게 2개의 차원인 행(Row), 열(Column)으로 구성되어 있으므로, 2개의 index를 부여해야한다.
• Matrix[행index,열index]로 행렬 데이터에 접근할 수 있다.
• Indexing 예시는 다음과 같다.
  • Matrix[row_id, col_id]
    : 행렬의 row_id 행과 col_id 열에 지정된 값을 가지고 온다. 이 때, row_id나 col_id에 벡터를 사용하여 여러 값을 지정할 수 있다. row_id나 col_id 둘 중 하나를 생략하면 전체 행이나 열을 뜻한다.
  • Matrix[1:3,]
    : 1~3 행의 데이터를 가지고 온다.
  • Matrix[-3,]
    : 3행의 데이터를 제외하고 모두 가지고 온다.
  • Matrix[c(1,3),]
    : 1, 3 행만 가지고 온다.
  • Matrix[,c("col5", "col3")]
    : 행렬 또한 행과 열에 부여된 이름으로 불러올 수 있다.
    
    ※ 접근한 행렬의 색인이나 이름의 순서에 따라서 행렬의 배열은 바뀌게 된다!

# 행렬에서 내가 원하는 데이터만 가지고 와보자.
vt = c(80, 60, 70, 75,
       90, 70, 60, 60,
       85, 90, 40, 70,
       80, 75, 90, 80,
       85, 80, 70, 65)
mat <- matrix(vt, nrow = 5, byrow = TRUE, dimnames = list(c("민철", "재성", "기훈", "재빈", "현희"), c("수학", "영어", "국어", "탐구")))
mat

※ 행렬과 같은 형태로 벡터를 생성한다면, 행렬 생성이 보다 편리하다.

##      수학 영어 국어 탐구
## 민철   80   60   70   75
## 재성   90   70   60   60
## 기훈   85   90   40   70
## 재빈   80   75   90   80
## 현희   85   80   70   65

# 행렬에서 민철, 기훈, 현희의 수학 점수와 국어 점수를 가지고 와보자..
mat[c("민철", "기훈", "현희"), c("수학", "국어")]

##      수학 국어
## 민철   80   70
## 기훈   85   40
## 현희   85   70

# 행렬에서 2번 행부터 4번 행까지 가지고 와보자.
mat[2:4,]

##      수학 영어 국어 탐구
## 재성   90   70   60   60
## 기훈   85   90   40   70
## 재빈   80   75   90   80

# 행렬에서 3번째 행만 제외하고 가지고 와보자.
mat[-3,]

##      수학 영어 국어 탐구
## 민철   80   60   70   75
## 재성   90   70   60   60
## 재빈   80   75   90   80
## 현희   85   80   70   65

# 행렬에서 1, 3 행만 가지고 와보자.
mat[c(1,3),]

##      수학 영어 국어 탐구
## 민철   80   60   70   75
## 기훈   85   90   40   70

# 행렬에서 국어 점수와 수학 점수 순서로 가지고 와보자.
mat[,c("국어", "수학")]

##      국어 수학
## 민철   70   80
## 재성   60   90
## 기훈   40   85
## 재빈   90   80
## 현희   70   85

행렬의 연산

: 행렬 내부에서 할 수 있는 연산과 행렬과 스칼라 간의 연산, 행렬과 행렬 간의 연산에 대해 알아보자.

행렬 내 연산

• rowMeans() / colMeans()
  : 행의 평균을 구한다. / 열의 평균을 구한다.
• rowSums() / colSums()
  : 행의 합을 구한다. / 열의 합을 구한다.
• 위 행렬을 기반으로 실습을 해보자.
  ※ Indexing과 조합하여 내가 원하는 값만 가지고 와서 연산해보도록 하자.

# 위 행렬이 1반이라고 가정할 때, 1반 학생들 개개인의 총 점수를 구하자.
rowSums(mat)

## 민철 재성 기훈 재빈 현희 
##  285  280  285  325  300

# 1 반 학생들의 과목별 평균 점수를 구하자.
colMeans(mat)

## 수학 영어 국어 탐구 
##   84   75   66   70

# 민철, 기훈, 현희의 평균 점수를 구하자.
rowMeans(mat[c("민철", "기훈", "재빈"),])

##  민철  기훈  재빈 
## 71.25 71.25 81.25

# 재성, 재빈, 현희의 수학, 국어 점수의 평균 점수를 구하자.
rowMeans(mat[c("재성", "재빈", "현희"),c("수학", "국어")])

## 재성 재빈 현희 
## 75.0 85.0 77.5

# 1반의 수학 총점과 평균 점수를 구하자.
math_Vt = mat[,"수학"]
sum(math_Vt)

## [1] 420

mean(math_Vt)

## [1] 84

행렬과 스칼라 간의 연산

• 행렬과 스칼라 간의 연산은 아주 간단하다.
• + - * / ^ 등을 그대로 사용하면 된다.

mat1 = matrix(c(1:12), nrow = 3, byrow = TRUE)
mat1 + 10

##      [,1] [,2] [,3] [,4]
## [1,]   11   12   13   14
## [2,]   15   16   17   18
## [3,]   19   20   21   22

mat1 - 10

##      [,1] [,2] [,3] [,4]
## [1,]   -9   -8   -7   -6
## [2,]   -5   -4   -3   -2
## [3,]   -1    0    1    2

mat1 * 10

##      [,1] [,2] [,3] [,4]
## [1,]   10   20   30   40
## [2,]   50   60   70   80
## [3,]   90  100  110  120

mat1 / 10

##      [,1] [,2] [,3] [,4]
## [1,]  0.1  0.2  0.3  0.4
## [2,]  0.5  0.6  0.7  0.8
## [3,]  0.9  1.0  1.1  1.2

행렬과 행렬의 연산

• 행렬과 행렬의 연산은 다양한 전제 조건이 붙는다.
• 행렬의 합과 차를 하려면 두 행렬의 크기가 서로 같아야 하며, 행렬의 곱을 하려면 앞 행렬과 뒤 행렬의 열과 행의 수가 동일해야한다. 
• 행렬의 합과 차는 +, -로 기존 연산자와 동일하나 행렬간 곱은 %*%로 연산자가 다르다.
• 전치행렬을 이용하면 언제든지 행렬 곱을 할 수 있다.
  • 전치행렬은 각 원소의 행과 열을 바꾼 행렬로, 어떤 크기의 행렬이라도 전치 행렬을 만들 수 있다.
  • 전치 행렬은 행과 열을 교환한 것이므로, 언제든지 행렬곱을 할 수 있다.
    보다 엄밀히 말하면, 주대각선을 축으로 하는 반사 대칭을 가하여 얻은 행렬이라고 할 수 있다.
  • 전치 행렬은 t(행렬)을 하면 생성할 수 있다.

mat1 = matrix(c(1:12), nrow = 3, byrow = TRUE)
mat2 = matrix(c(12:1), nrow = 3, byrow = TRUE)

# 행렬간 합과 차를 해보자
mat1 + mat2

##      [,1] [,2] [,3] [,4]
## [1,]   13   13   13   13
## [2,]   13   13   13   13
## [3,]   13   13   13   13

mat1 - mat2

##      [,1] [,2] [,3] [,4]
## [1,]  -11   -9   -7   -5
## [2,]   -3   -1    1    3
## [3,]    5    7    9   11

# 전치행렬 곱을 해보자
mat1 %*%t(mat1)

##      [,1] [,2] [,3]
## [1,]   30   70  110
## [2,]   70  174  278
## [3,]  110  278  446

이번 포스트에서는 행렬의 Indexing과 행렬의 연산 등에 대하여 학습해보았다.

다음 포스트에선 역행렬을 비롯한 약간 독특한 형태의 행렬들에 대해 가볍게 학습해보자.

이번에는 행렬(matrix)에 대해 학습 해보자, 행렬은 통계 분석부터 요즘 핫한 딥러닝까지 두루 쓰이는 것으로, 행렬에 대해 자세히 파고 들어간다면, 몇 주 동안 행렬에 대해서만 다뤄도 부족할 것이다.

지금은 행렬에 대해 기초적인 수준에서 접근을 해볼 것이며, 총 3개의 파트로 나눠 학습해보고자 한다.

파트1에선 R에서 행렬의 생성과 기본적인 접근법, 파트2에선 행렬의 Indexing과 행렬 연산 등을 공부하고, 파트3에선 가운데 행렬과 같은 조금 특이한 행렬에 대해 학습하도록 하자.

행렬(Matrix)

: 벡터를 행과 열로 갖는 표 형식으로 확장한 것이 행렬이다.

• 행렬에는 한 가지 유형의 스칼라만 사용할 수 있다.
• 행렬에 들어가는 Data는 일반적으로 벡터가 들어간다.
  (즉, 1차원인 벡터를 2차원으로 바꾼 것을 행렬이라고 할 수 있다.)

행렬 생성

• matrix()
  : 행렬을 생성한다.
• 주요 Parameter
  : matrix(data, nrow: 행의 수, ncol: 열의 수, byrow: 행부터 데이터를 채움, dimnames: 행렬의 각 차원에 부여할 이름)

# matrix를 만들어보자.
vt = seq(from = 1, by = 2, length = 12)
mat = matrix(vt, nrow = 4, byrow = TRUE, dimnames = list(c("r1", "r2", "r3", "r4"), c("c1", "c2", "c3")))
mat

※ dimnames에 들어간 list는 추후 공부할 데이터 타입으로, n개의 데이터  타입을 담을 수 있는 형태라고 보면 된다.
자세한 것은 추후 학습하도록 하자.

##    c1 c2 c3
## r1  1  3  5
## r2  7  9 11
## r3 13 15 17
## r4 19 21 23

행렬의 크기와 벡터의 길이가 다를 경우

• 만약, 벡터의 길이가 행렬을 구성하기에 적합하지 않은 길이인 경우, 오류 메시지가 발생하고 벡터의 앞부분부터 행렬의 빈자리에 들어가게 된다.

# matrix를 만들어보자.
vt_diff = seq(from = 1, by = 2, length = 10)
mat_diff = matrix(vt_diff, nrow = 5, ncol = 4, byrow = TRUE)
mat_diff

##      [,1] [,2] [,3] [,4]
## [1,]    1    3    5    7
## [2,]    9   11   13   15
## [3,]   17   19    1    3
## [4,]    5    7    9   11
## [5,]   13   15   17   19

• 위 행렬에서 볼 수 있듯이 3행 3열부터 Data로 들어간 벡터가 처음부터 값이 입력되었다.

행렬의 기본적인 정보를 가지고 와보자.

# 대상이 될 행렬.
vt = seq(from = 1, by = 2, length = 12)
mat <- matrix(vt, nrow = 4, byrow = TRUE, dimnames = list(c("r1", "r2", "r3", "r4"), c("c1", "c2", "c3")))

1) 행렬의 차원별 이름 가지고 오기.

• dimnames()
  : 객체의 각 차원 이름을 가지고 온다.(dim = dimension)
• rownames()
  : 행렬의 행 이름을 가지고 온다.
  
• colnames()
  : 행렬의 열 이름을 가지고 온다.

# 행렬의 각 차원 이름을 모두 가지고 와보자.
dimnames(mat)

## [[1]]
## [1] "r1" "r2" "r3" "r4"
## 
## [[2]]
## [1] "c1" "c2" "c3"

# 행렬에서 행 이름을 가져와보자.
rownames(mat)

## [1] "r1" "r2" "r3" "r4"

# 행렬에서 열 이름을 가져와보자.
colnames(mat)

## [1] "c1" "c2" "c3"

2) 행렬에 다른 이름을 부여해보자.

• 행렬의 차원별 이름 바꾸기는 들어가는 데이터 타입만 다를 뿐 벡터와 동일하다.

# 행렬에 다른 이름을 부여해보자.
dimnames(mat) <-list(c("a1", "a2", "a3", "a4"), c("b1", "b2", "b3"))
mat

##    b1 b2 b3
## a1  1  3  5
## a2  7  9 11
## a3 13 15 17
## a4 19 21 23

# 행의 이름을 바꿔보자.
rownames(mat) <- c("행1", "행2", "행3", "행4")
mat

##     b1 b2 b3
## 행1  1  3  5
## 행2  7  9 11
## 행3 13 15 17
## 행4 19 21 23

#열의 이름을 바꿔보자.
colnames(mat) <- c("열1", "열2", "열3")
mat

##     열1 열2 열3
## 행1   1   3   5
## 행2   7   9  11
## 행3  13  15  17
## 행4  19  21  23

3) 행렬의 크기에 관한 정보를 가지고 와보자.

• nrow()
  : 행렬의 행의 갯수
• ncol()
  : 행렬의 열의 갯수
• dim()
  : 행렬의 차원별 크기
• length()
  : 행렬 내 원소들의 수 (벡터의 길이와 동일하다!)
• mode()
  : 행렬 내 원소의 타입 확인
• str()
  : 행렬뿐만 아니라 벡터, 데이터 프레임 등에서도 사용되는 것으로, 원소의 양, 차원, 차원 이름, 원소의 타입 등 데이터의 전반적인 정보를 가지고 온다.

# 행렬의 행의 갯수를 가지고 와보자.
nrow(mat)

## [1] 4

# 행렬의 열의 갯수를 가지고 와보자.
ncol(mat)

## [1] 3

# 행렬의 차원별 크기를 가지고 와보자.
dim(mat)

## [1] 4 3

# 행렬에 있는 원소의 수를 가지고 와보자
length(mat)

## [1] 12

# 행렬의 원소 타입을 확인해보자.
mode(mat)

## [1] "numeric"

# 행렬의 정보들을 정리해서 봐보자!
str(mat)

##  num [1:4, 1:3] 1 7 13 19 3 9 15 21 5 11 ...
##  - attr(*, "dimnames")=List of 2
##   ..$ : chr [1:4] "r1" "r2" "r3" "r4"
##   ..$ : chr [1:3] "c1" "c2" "c3"

4) 행렬의 형태를 바꿔보자.
: 행렬의 차원 변경은 원소의 수가 같다면 쉽게 할 수 있다.

# 행렬의 차원을 바꿔보자.
dim(mat) <- c(2,6)
mat

##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]    1   13    3   15    5   17
## [2,]    7   19    9   21   11   23

벡터들을 합쳐서 행렬을 만들어보자.

• 두 개 이상의 벡터를 묶어서 행렬을 만들어보자.
• cbind()
  : 열로 벡터들을 묶는다.
• rbind()
  : 행으로 벡터들을 묶는다.
• rbind()나 cbind()는 Matrix뿐만 아니라 R에서 가장 많이 쓰이는 데이터 타입인 DataFrame에서도 쓰인다.
• 만약 벡터의 길이가 동일하지 않는다면, 경고문을 띄운 후 길이가 가장 긴 벡터에 맞게 다른 벡터들은 앞부분부터 뒤에 추가하여 생성된다.

vt1 = c(1:6)
vt2 = c(8:3)
vt3 = rep(c(1,2,3), times = 2)
vt4 = c("a", "b", "c", "d", "e", "f")
vt5 = c(1:10)

# 열로 묶어보자
cbind(vt1, vt2, vt3)

##      vt1 vt2 vt3
## [1,]   1   8   1
## [2,]   2   7   2
## [3,]   3   6   3
## [4,]   4   5   1
## [5,]   5   4   2
## [6,]   6   3   3

# 행으로 묶어보자
rbind(vt1, vt2, vt3)

##     [,1] [,2] [,3] [,4] [,5] [,6]
## vt1    1    2    3    4    5    6
## vt2    8    7    6    5    4    3
## vt3    1    2    3    1    2    3

# 숫자 벡터에 문자 벡터를 섞어보자
cbind(vt1, vt2, vt3, vt4)

##      vt1 vt2 vt3 vt4
## [1,] "1" "8" "1" "a"
## [2,] "2" "7" "2" "b"
## [3,] "3" "6" "3" "c"
## [4,] "4" "5" "1" "d"
## [5,] "5" "4" "2" "e"
## [6,] "6" "3" "3" "f"

※ 숫자형 벡터와 문자형 벡터를 하나의 행렬로 묶는 경우, 행렬엔 하나의 변수 타입만 들어갈 수 있으므로 character형으로 바뀐 것을 볼 수 있다.

# 길이가 다른 벡터를 추가해보자
cbind(vt1, vt2, vt3, vt5)

## Warning in cbind(vt1, vt2, vt3, vt5): number of rows of result is not a multiple
## of vector length (arg 1)

##       vt1 vt2 vt3 vt5
##  [1,]   1   8   1   1
##  [2,]   2   7   2   2
##  [3,]   3   6   3   3
##  [4,]   4   5   1   4
##  [5,]   5   4   2   5
##  [6,]   6   3   3   6
##  [7,]   1   8   1   7
##  [8,]   2   7   2   8
##  [9,]   3   6   3   9
## [10,]   4   5   1  10

※ 길이가 다른 벡터가 추가 되면, 길이가 짧은 벡터들은 앞 부분부터 반복하여 생성되는 것을 알 수 있다.

지금까지 행렬에 대한 기본적인 정보를 가지고 노는 법에 대해 학습해보았다.

눈치가 빠른 사람이라면, 행렬의 이름 부여, 크기 보기 등이 꽤나 비슷한 것을 알 수 있는데, R에서 사용하는 대부분의 데이터 형태 조작 방법이, 이 틀에서 크게 벗어나지 않는다는 점이, R로 데이터를 가지고 놀 때 매우 편리한 부분이다.

다음 포스트에선 행렬 데이터 접근(Indexing), 행렬의 연산에 대하여 다뤄보도록 하겠다.

이번 포스트에선 연산자와 변수의 타입에 대해 공부해보자.

논리연산자(Logical Operators)

: 논리연산자는 if문과 같이 조건을 부여하는 경우 사용되는 연산자로 매우 자주 쓰이니 꼭 기억하도록 하자.

※ 매치 연산자(Matching operator): %in% 기호로 변수의 값이 지정한 조건 목록에 해당하는지 확인하는 기능을 한다.

산술연산자(Arithmetic Operator)

: 계산을 할 때 사용되는 기호이므로, R을 사용할 때, 상식이라고 할 수 있으니 절대 잊지 말자!

변수 타입(Variable Type)

: R이 기본적으로 가지고 있는 변수 타입이다. R을 사용할 때, 꼭! 신경써야하는 부분으로, 변수 타입이 잘못된 경우, 오류가 발생할 수 있다.

※ 반대로 말하자면 변수 타입만 잘 잡아도 꽤 많은 오류를 방지할 수 있다.

이번 포스트는 매우 짧지만 엄청 중요한 내용이므로, 상식처럼 알고 있어야한다.

다음 포스트에선 데이터 타입: 행렬에 대해 공부해보자.