R | JDW Blog

코랩에서 Rstudio 사용하기 1. Rstudio-server 설치하기

Tue, 24 Oct 2023 00:00:00 +0000

최근 나만의 딥러닝 워크스테이션 구성하기 프로젝트를 진행하면서 다방면으로 찾아보던 중 문득 Colab을 통해 Rstudio를 구동할 수 있지 않을까 싶었다. 그래서 찾아보니까 실제로 나와 같은 생각을 한 사람이 있었고, 직접 테스트를 진행해보니 성공적으로 Colab의 리소스로 Rstudio를 오픈 시킬 수 있어서 이를 소개하고자 한다.

Google Colaboratory

(이하 코랩)은 구글에서 제공하는 데이터 사이언스와 머신러닝을 위한 클라우드 기반 Python 개발 환경이다. 코랩의 장점은 여러가지 있지만 아무래도 무료로 Jupyter notebook을 사용할 수 있는 점을 꼽을 수 있겠다. 물론 free tier로 사용시에 리소스의 제한이 꽤나 엄격하지만 그래도 인터넷이 연결이 되고 Python을 다룰줄만 안다면 장소에 구애받지 않고 어디서든 작업을 할 수 있는 부분에 있어서는 유용한 서비스다.

코랩은 기본적으로 Ubuntu 기반의 가상머신에서 서버 리소스가 할당되어 사용되는 구조인듯 싶다. 코랩에서 사용되는 OS에 대한 기본 정보는 Jupyter notebook의 매직 명령어를 활용하여 확인할 수 있다.

!cat /etc/*release

DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=22.04
DISTRIB_CODENAME=jammy
DISTRIB_DESCRIPTION="Ubuntu 22.04.2 LTS"
PRETTY_NAME="Ubuntu 22.04.2 LTS"
NAME="Ubuntu"
VERSION_ID="22.04"
VERSION="22.04.2 LTS (Jammy Jellyfish)"
VERSION_CODENAME=jammy
ID=ubuntu
ID_LIKE=debian
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
UBUNTU_CODENAME=jammy

Note

본격적으로 들어가기에 앞서 본 포스팅은 해당 를 활용하여 작성되었음을 알립니다.

Rstudio-server 설치

기본적인 접근은 다음과 같다. 먼저 코랩 자체가 Ubuntu환경에서 실행되는 만큼 리눅스 우분투용 R과 Rstudio를 설치한다. 일반적으로 Ubuntu 환경 하에서는 로컬 웹 기반 Rstudio-server를 설치하여 활용하는데, 설치를 마치고 설치된 해당 주소와 포트를 터널링을 통해 접근하는 방식으로 진행된다. 각자 코랩을 켜서 아래의 code-chunk를 복사하여 셀 바이 셀로 실행시켜 나가면 된다.

1. rstudio 유저 추가

!sudo useradd --create-home --user-group --password $(echo '1234' | openssl passwd -1 -stdin) rstudio
!usermod -aG sudo rstudio
!su rstudio -c 'echo 1234 | sudo -S chmod -R 777 /var/log'

먼저 우분투 환경에서 “rstudio” 사용자를 생성하고 sudo 권한을 부여한다. 이는 rstudio-server 로그인에 필요한 과정이다. 마지막 세번째 줄에 있는 !su rstudio -c 'echo 1234 | sudo -S chmod -R 777 /var/log'코드는 지금은 직접적인 연관이나 필요는 없지만 추후에 진행할 tensorflow-R을 설치할때 필요로 하기 때문에 미리 처리를 해 놓음.

비밀번호의 경우 현재 1234로 세팅을 해 놓았는데 혹시라도도 rstudio-server 로그인 비밀번호를 바꾸고 싶다하면 코드에 있는 1234를 원하시는 비밀번호로 적어서 실행시키면 된다.

2. 필수 프로그램 설치

GIS software

%%capture # 출력 생략 
!apt-get update
!apt-get install --yes git ssh python3-venv
!apt-get install r-base r-base-dev gdal-bin python-gdal python3-gdal libgdal-dev libproj-dev proj-data proj-bin libgeos-dev libudunits2-dev libv8-dev libprotobuf-dev libxml2 libjq-dev
!apt-get install qgis saga

R 설치와 더불어 python3 가상환경 모듈 및 지리 정보 및 공간 데이터 시각화를 위한 연계 패키지들을 설치

Github CLI

%%capture
!apt-key adv --keyserver keyserver.ubuntu.com --recv-key C99B11DEB97541F0
!echo | sudo apt-add-repository https://cli.github.com/packages
!apt update
!apt install gh

Github 사용을 위한 Github CLI(명령줄 인터페이스) 패키지 설치

rstudio server

%%capture
!apt-get install gdebi-core
!wget https://download2.rstudio.org/server/focal/amd64/rstudio-server-2023.09.1-494-amd64.deb
!sudo gdebi rstudio-server-2023.09.1-494-amd64.deb

rstudio-server 설치 진행
업데이트 시 배포되는 rstudio-server 버전이 바뀌므로 최신 버전으로 사용을 원한다면 에서 최신 버전의 코드로 바꿔서 실행

<rstudio-server posit 다운로드 페이지>

ngrok 토큰 발급

다음으로 진행해야 할 것으로 ngork 서비스 관련 사항들이다. ngork는 로컬의 개발환경을 인터넷으로 공개적으로 접근 가능하게 만들어주는 터널링(Tunneling) 서비스라고 한다. 주로 시스템 혹은 웹 개발시 테스트의 용도나 디버깅 작업을 수행하는데 사용되는 서비스인데 우리는 이것을 통해 코랩 내부의 rstudio-server 로컬 주소 및 포트를 접근할 수 있는 주소를 만드는데 사용할 것. 다음에 사이트에서 ngork 가입 및 토큰을 발급을 진행하면 된다.

<ngork account 토큰 발급>

from getpass import getpass

# Don't forget create your account of ngrok and get token from https://dashboard.ngrok.com/auth/your-authtoken
authtoken = getpass("Input your Auth token")

발급받은 토큰을 복사하여 아래의 코드 실행 시 생성된 입력 창에 입력

! wget -q -c -nc https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip
! unzip -qq -n ngrok-stable-linux-amd64.zip

wget과 unzip 명령을 통해 ngrok을 다운로드하고 압축을 해제하여 코랩 환경에서 IP 터널링을 가능케 함

3. ngrok을 통한 Rstudio server 가동

마지막으로 앞서 설정한 ngork 토큰을 통해 코랩 로컬에서 실행되어 있는 rstudio-server 웹 서버를 공용 IP 주소로 터널링하여 접근을 진행한다. 아래의 코드를 실행시키면 나오는 주소가 바로 코랩으로 실행시킨 rstudio-server의 웹 주소이므로 출력하여 나오는 주소로 접속.

# Run ngrok
get_ipython().system_raw('./ngrok authtoken $authtoken && ./ngrok http 8787 &')
! sleep 3

# Get the address for Rstudio-server
import requests
from re import sub
r = requests.get('http://localhost:4040/api/tunnels')

str_ssh = r.json()['tunnels'][0]['public_url']
print(str_ssh)

#> https://af9e-105-199-235-17.ngrok-free.app # 출력 예시

<ngork tunneling 및 Rstudio-server login, main 페이지>

출력으로 나온 ngork 터널링 페이지에서 Visit Site를 클릭하면 우리가 설정한 rstudio-server의 로그인 화면을 볼 수 있고, 이 후에 앞서 설정한 로그인 입력정보(ID : rstudio, PW : 1234)를 입력하게 되면 비로소 코랩에서 코랩의 리소스를 통한 Rstudio 사용 가능하다.

References

(Github repository)
(.ipynb)

[R] 더욱 빠른 연산을 위한 병렬처리(With future Package)

Mon, 22 Feb 2021 00:00:00 +0000

사진출처 : mohamed Hassan from Pixabay

계산할게 많은 코드를 돌릴때면 당연하게도 많은 시간을 소모하게 됩니다. 통계모델구축과 같이 연산량이 많은 작업을 돌리는 경우에 종종 이러한 상황을 맞닥들이곤 하는데요. 코드가 돌아가는 시간동안은 어쩔수 없이 하고있는 업무를 잠시 중단하거나 다른 일을 하는 수 밖에 없는 상황입니다. 이와 같은 시간이 아깝다고 생각이 드는건 지극히 정상적인 생각일 것입니다. 코드의 결과물이 빨리 나올수록 하고 있는 일을 더 빨리 끝내거나 혹은 그 시간에 더 많은 일을 할 수 있는데 말이죠. 오늘은 이러한 코드의 연산에 필요한 시간을 어쩌면 획기적으로 줄여줄수 있는 future 패키지에 대해 알아보겠습니다.

CPU

설명하기에 앞서 여려분은 R을 어떠한 환경에서 사용하고 계신가요? 노트북 또는 데스크탑, 클라우드 환경 등 다양한 환경에서 R을 사용하고 계실겁니다. 저는 윈도우가 탑제된 노트북에서 R을 사용하고 있는데요. 제가 사용하고있는 노트북의 CPU는 로 헥사코어(6개의 코어)와 인텔의 하이퍼쓰레딩 기술이 적용된 제품을 사용하고 있습니다. CPU는 들어봤어도 헥사코어니 하이퍼쓰레딩이니하는 용어에 대해서 처음 들어보시는 분들도 계실겁니다. 저와 같은 컴알못(컴퓨터를 잘 알지 못하는)분들에게는 이런 생소한 용어 하나하나가 어려움으로 다가올텐데요. 이 후에 후술할 병렬처리를 이해하기 위해서는 이러한 부품들의 역할과 기능을 이해하고 있어야 하기 때문에 이런 용어를 설명해야 하는점 미리 양해를 구하겠습니다. 혹시나 이와같은 개념을 이미 알고 계신다면 넘어가셔도 상관 없습니다.

코어 & 쓰레드

용어에 대한 설명을 진행하겠지만 본 포스트는 컴퓨터 용어에 대한 것이 아니기 때문에 최대한 간단하게 해보도록 하겠습니다. 먼저 컴퓨터의 두뇌라 할수있는 CPU에는 코어라는 것이 존재하는데 코어는 CPU에서 실질적으로 연산을 담당하는 장치입니다. 과거에는 CPU당 1개의 코어가 들어갔었으나 기술이 발전하면서 현재 출시되는 CPU에는 많게는 코어가 32개까지 들어가는 멀티코어로 구성되어 있습니다.

이러한 코어에는 쓰레드라는 개념이 존재하는데, 쓰레드는 코어에 할당된 작업 공간입니다. 즉, CPU 내부에서 일을 처리하는 최소의 단위이며 코어가 일을 하는 노동자라고 하면 쓰레드는 노동자가 동시에 할 수 있는 업무의 갯수라고 이해하면 될 것 같습니다.

CPU 내부 코어의 구성

예시로 든 이미지에 있는 CPU는 4개의 코어가 들어간 쿼드코어 CPU로서 당연한 말이지만 2개의 코어를 지닌 듀얼코어나 싱글코어의 CPU보다 높은 성능을 낼 것입니다. 한편 인텔에는 하이퍼쓰레딩이라는 기술이 존재하는데 일반적으로 CPU의 코어는 코어당 하나의 쓰래드를 배분받아 일을 하게 되지만 해당 기술은 하나의 코어가 두 개의 쓰레드를 할당받아 마치 2개의 코어처럼 작동을 하는 것을 의미합니다. 즉, 헥사코어에 하이퍼쓰레드 기술을 지니고 있는 저의 노트북같은 경우는 동시에 연산처리를 할 수 있는 실질적인 코어가 총 12개가 있는 것이죠.

“CPU-Z” 프로그램으로 알아본 CPU 정보 및 코어 & 쓰레드 갯수

병렬처리와 비동기 프로그래밍

한가지 상황을 상상해보죠. 오늘 저녁은 직접 요리를 해서 먹기로 마음 먹었습니다. 오늘은 집에서 갈비찜에 시금치 무침, 잡채, 그리고 김치볶음밥을 하기로 정했죠. 요리를 위한 재료구입과 다듬기를 마친 상황이고, 이제 한참 갈비찜을 만들고 있었습니다. 그런데 생각보다 갈비찜을 만드는데 시간이 많이 소요가 됩니다. 양념장에 재운 갈비를 끓여 익히기만 하면 되는데 그 시간이 한시간정도 걸린다고 합니다. 이럴경우 보통 어떻게 해야 할까요? 당연하게도 갈비를 익히는 시간동안 다른 잡채나 시금치 무침을 하면 됩니다.

그러던 와중에 집에서 요리한다는 소식을 접한 친구가 갑작스럽게 우리집에 방문한다고 합니다. 잘됐습니다. 공짜로 얻어먹으려는 친구를 부려서 같이 요리 하면 좋겠네요. 아마도 시간이 훨씬 단축될 것입니다. 원래라면 두 시간 걸릴 요리가 친구가 도와줌으로 인해서 한 시간 정도로 단축 될 것 같네요.

혼자 처리할 일을 친구와 같이 함으로서 시간이 단축되는 것 처럼 단일 프로세스에서 처리할 일을 여러 프로세스와 함께 처리하는 방식을 병렬처리라고 합니다. 그리고 일반적인 R 코드는 순차적으로 처리를 하지 동시에 처리하는것은 불가능합니다. 이를 위의 상황에 비유하자면 갈비찜과 잡채를 만들고 있는 상황에서 갈비찜이 완성되기 전까지는 잡채나 시금치 무침같은 다른 요리를 만드는 것에는 일절 손도 안대는 상황이라 할 수 있습니다. 이처럼 작업의 순서가 고정되어 있지 않고 주어진 일을 여건에 맞게 유기적으로 처리하는 방식을 비동기(Async) 방식이라 하며, 반대로 주어진 일을 순차적으로 처리하는 방식을 동기식(Sync)이라 합니다.

future package

동기식으로 처리되던 기존의 R 코드를 future 패키지를 사용한다면 효율적이고 그리고 손쉽게 병렬 처리 및 비동기 연산을 할 수 있습니다.

설치 및 기본 설정

future 패키지는 cran에 정식으로 등록된 패키지이기 때문에 install.packages()함수를 사용하여 설치가 가능합니다.

# install.packages(future)
library(future)

패키지를 설치하였다면 비동기 연산을 위한 설정을 별도로 진행해 줘야 합니다. future 패키지가 제공하는 plan() 함수는 코드 연산 방식을 동기식으로 할지 비동기식으로 할지 설정하도록 하는 함수입니다. 여기에 인자로 multisession 을 지정하면 future 패키지가 백그라운드에서 자동적으로 별도의 R 세션을 생성하고, 이후 병렬연산이 필요한 경우에 사용할 수 있습니다. (MAC 이용자의 경우 plan(multicore)로 설정하시면 됩니다.)

plan(multisession)

plan() 함수를 실행하면 현재 환경에서 사용 가능한 전체 CPU의 코어를 자동으로 탐지하여 이 갯수만큼의 R 세션을 생성하게 됩니다. 저의 노트북을 예시로 들면 12개의 세션을 백그라운드에서 생성하게 되죠. 만약 전체 CPU의 코어 사용이 부담스럽다면 plan() 함수가 제공하는 workers 옵션을 설정하면 원하는 만큼의 코어를 사용할 수 있습니다. 여기서는 8개의 코어만 사용해 보도록 하겠습니다.

# 기본 설정 코어 갯수 & 실행 가능한 최대 CPU 코어
availableCores()

#> system
#> 12

# 사용 코어 갯수 지정
plan(multisession, workers = 8)

이렇게 설정되어 만들어진 세션들은 (윈도우)작업관리자를 통해 확인할 수 있습니다. plan()함수를 통해 ‘R for Windows front-end’ 세션들이 새로이 생성된 것을 볼 수 있습니다.

기본 세션(좌), plan(multisession)으로 생성된 백그라운드 세션(우)

기본 용법

future 패키지를 사용하는 방법에는 두가지 방식이 있습니다. 하나는 future() 함수를 명시적으로 사용하는 것이고 다른 하나는 패키지에서 제공하는 %<-% 형태의 특수한 연산자를 사용하여 퓨쳐를 암시적으로 지정하는 것입니다.
비교를 위해 임의의 함수 하나를 생성해서 사용해보도록 하겠습니다. testFunc1() 함수는 단순히 ‘hi’라는 단어를 콘솔창에 출력한 뒤 3.14를 반환하는 함수입니다.

testFunc1 <- function(){
 cat('hi')
 3.14
}

그런다음 future 의 명시적 용법과 암시적 용법을 각각 사용하여 testFunc1() 함수를 출력해보도록 하겠습니다. 두 방식 모두 이전에 설정한 plan(multisession) 함수를 통해 비동기 방식을 설정한 상태이며, 이를 통해 연산이 현재의 R studio 세션에서 진행되는 것이 아닌 백그라운드 세션에서 이루어집니다.

# 명시적 용법 
f1 <- future({
 testFunc1()
})

# 암시적 용법 
f2 %<-% {
 testFunc1()
}

f1

#> MultisessionFuture:
#> Label: '<none>'
#> Expression:
#> {
#> testFunc1()
#> }
#> Lazy evaluation: FALSE
#> Asynchronous evaluation: TRUE
#> Local evaluation: TRUE
#> Environment: R_GlobalEnv
#> Capture standard output: TRUE
#> Capture condition classes: 'condition'
#> Globals: 1 objects totaling 5.21 KiB (function 'testFunc1' of 5.21 KiB)
#> Packages: <none>
#> L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
#> Resolved: TRUE
#> Value: <not collected>
#> Conditions captured: <none>
#> Early signaling: FALSE
#> Owner process: 81d55a71-a4c6-da64-cea2-9ca8570374dc
#> Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'

f2

#> hi

#> [1] 3.14

암시적 용법을 사용한 f2 의 경우 testFunc1() 함수의 output을 정상적으로 출력하였지만 명시적 용법을 사용한 f1 객체의 경우는 다소 알기 어려운 메세지만을 출력하였습니다. future 패키지에서 명시적 용법과 암시적 용법은 기본적으로 같은 기능을 수행하지만 명시적 용법을 사용하는 경우 값을 반환받기 위해서는 value() 함수를 통해 반환을 받습니다.

value(f1)

#> hi

#> [1] 3.14

value() 함수를 사용하니 f1 객체 역시 f2 와 동일한 값을 반환합니다. 이처럼 명시적 용법을 사용한 퓨쳐에서는 값을 반환받기 위해 value() 함수를 사용해야 하며, 간결하게 사용하고 싶은 경우에는 암시적 용법인 %<-% 연산자를 사용하면 됩니다.

활용

지금까지 future 패키지의 설치와 기본적인 사용법에 대해서 알아보았습니다. 그렇다면 어떠한 상황 혹은 어떠한 목적을 위하여 이것을 사용해야 할까요? 여러가지 상황이 존재하겠지만 제가 생각하기에 future 패키지를 알맞게 사용하는 상황은 크게 두 가지 인 것 같습니다.

1) 연산을 다른 세션에 위임할 때

맨 처음 말한것처럼 연산량이 많은 코드를 돌릴 경우 코드가 온전히 돌아갈때 까지 기다려야 하는 상황이 발생합니다. 갈비찜이 완성되기 전까지는 아무런 동작도 하지 않는셈이죠. 이럴때 future 패키지를 사용하면 현재 작업하고 있는 세션에 방해되지 않게 코드를 돌릴 수가 있습니다.

testFunc2 <- function(x){
 Sys.sleep(x)
 return(print('Done!'))
}

시범을 위해 역시 임의의 함수를 생성하도록 하겠습니다. testFunc2() 함수는 지정한 x초 만큼 동작을 멈추었다가 마지막에 print('Done!')을 수행하는 함수입니다. 즉, x초간 멈추는 동작을 수행 한 뒤 ‘Done!‘이란 글자를 출력하는 함수이죠. 이를 계산이 오래 걸리는 함수라고 가정하고 다른 세션에 위임하여 10초동안 돌려보도록 하겠습니다.

# 다른 세션에서 연산하도록 위임 
t1 <- future({
 testFunc2(10)
})

# 결과 출력 
value(t1)

#> [1] "Done!"

future 패키지를 통해 연산을 다른 세션에 위임한다는 사실을 알게 되었습니다. 그런데 다른 세션에서 작업이 완료가 되었는지 확인은 어떻게 해야할까요? 현재 세션에서 코드를 돌린다면 코드의 연산이 끝날 시 콘솔창에 즉각 출력이되어 코드의 수행 여부를 즉각 확인할 수 있을 것입니다. 그렇지만 다른 세션에서 돌아간 코드는 연산이 끝나더라도 현재 세션에 아무런 영향을 주지 않기 때문에 이를 확인할 방도가 없습니다.

이러한 상황을 대비하여 future 패키지는 resolved() 함수를 제공하고 있습니다.

# 다른 세션에 연산 위임 
t2 <- future({
 testFunc2(10)
})

# 연산 확인 
i = 0
while(T){
 cat(paste0(i, ' now running \n'))
 Sys.sleep(1)
 i = i + 1
 if(resolved(t2)){
 cat('Calculate done! \n')
 break
 }
}

# 결과 출력 
value(t1)

#> 0 now running
#> 1 now running
#> 2 now running
#> 3 now running
#> 4 now running
#> 5 now running
#> 6 now running
#> 7 now running
#> Calculate done!
#> [1] "Done!"

t2 객체가 현재 연산중인지를 확인하기 위하여 중간에 while 문을 추가하였습니다. while 문의 기능은 1초 간격으로 동작을 멈추었다가 “i now running"을 출력하는 코드인데 중간에 있는 if 문에 resolved(t2) 함수가 있는 것을 볼 수 있습니다. resolved() 함수의 기능은 백그라운드 세션에서 연산중인 퓨쳐가 동작하는지를 확인하기 위한 함수로서 만약 해당 퓨쳐가 연산중에 있으면 FALSE 를, 연산을 마쳤다면 TRUE 를 반환하게 됩니다. 따라서 t2 객체에 지정된 퓨쳐가 백그라운드 세션에서 연산중이면 “i now running” 출력과 1초 간격으로 동작을 멈추는 작동을 수행하고, 연산이 끝난경우 if 문 내부의 break 를 통해 while 문이 종료가 되는 것입니다. 이와 같은 방법을 응용한다면 백그라운드에서 실행중인 비동기 연산의 수행완료 여부를 효율적으로 인지할 수 있을 것입니다.

2) 더욱 빠른 연산이 필요로 할 때

2-1) 파일 읽기 속도 비교

두 번째 경우는 연산속도를 높이고 싶은 상황에 사용하는 것입니다. future 패키지가 지원하는 병렬연산을 적극 사용하는 방식인데 속도의 비교를 위해 테스트용 데이터를 생성해 보도록 하겠습니다.

# 테스트용 csv 저장
library(dplyr)
data.frame(
 t1 = rnorm(10000),
 t2 = rnorm(10000),
 t3 = rnorm(10000)
) %>% write.csv(., 'testFile.csv')

정규분포를 따르는 난수를 생성하는 rnorm() 함수를 사용하여 3개의 column과 10000개의 row를 지니고 있는 임의의 데이터프레임을 생성하였고, 이를 csv파일로 저장하였습니다. R 에서 제공하는 다양한 반복 처리 기법들을 사용하여 생성한 csv파일을 각각 500번씩 읽어들이는데 소요된 속도를 system.time() 함수를 사용하여 비교해보도록 하겠습니다.

# 테스트 결과 리스트에 저장
speed_result <- list()
speed_result <- list(
 # for문
 forLoop = system.time({
 for(i in 1:500){
 read.csv('testFile.csv')
 }
 }),

 # lapply문
 lapply = system.time({
 lapply(1:500, function(x){
 read.csv('testFile.csv')
 })
 }),

 # sapply문
 sapply = system.time({
 sapply(1:500, function(x){
 read.csv('testFile.csv')
 })
 }),

 # purrr::map문
 map = system.time({
 purrr::map(1:500, function(x){
 read.csv('testFile.csv')
 })
 }),

 # future문
 future = system.time({
 future({
 lapply(1:500, function(x){
 read.csv('testFile.csv')
 })
 }) %>% value()
 })
)

speed_result

#> $forLoop
#> 사용자 시스템 elapsed
#> 20.42 0.47 20.97
#>
#> $lapply
#> 사용자 시스템 elapsed
#> 21.04 0.41 21.52
#>
#> $sapply
#> 사용자 시스템 elapsed
#> 21.29 0.34 21.69
#>
#> $map
#> 사용자 시스템 elapsed
#> 21.47 0.34 21.86
#>
#> $future
#> 사용자 시스템 elapsed
#> 0.08 0.08 20.28

future 패키지를 사용하였음에도 불구하고 예상한것과 달리 속도 개선이 그리 와닿지 않습니다. 다른 기법들과 속도가 비슷하거나 purrr::map() 함수와 비교해보면 되려 속도가 느린 것을 볼 수 있습니다. 여기서 한가지 더 짚고 넘어가야 할 점이라면 future 패키지를 통해 속도개선을 위한다면 다음의 패키지들을 추가적으로 설치하여 사용하는 것을 추천합니다.

install.packages('future.apply')
install.packages('furrr')

future 패키지의 확장 패키지들인 future.apply , furrr 패키지는 병렬 환경에서 각각 apply 문과 purrr 패키지의 함수를 대체하여 사용할 수 있는 future.apply::future_apply() 또는 furrr::future_map() 등의 함수를 제공하고 있습니다.

# future_lapply 속도 측정 
library(future.apply)
list(
 future_apply = system.time({
 future_lapply(1:500, function(x){read.csv('testFile.csv')})
 })
)

#> $future_apply
#> 사용자 시스템 elapsed
#> 0.22 0.20 8.53

# future_map 속도 측정 
library(furrr)
list(
 future_map = system.time({
 future_map(1:500, function(x){read.csv('testFile.csv')})
 })
)

#> $future_map
#> 사용자 시스템 elapsed
#> 0.28 0.16 7.72

future() 함수의 속도 대비 훨신 빠른 성능을 보인 것을 확인할 수 있습니다.

2-2) 모델링 속도 비교

이번에는 실제 모델링에서의 연산속도는 어떠할지 측정해 보도록 하겠습니다. 시계열분석 예제 데이터로 많이 활용되는 AirPassengers 데이터에 난수를 더하여 만든 50개의 시계열 데이터에 각각 ARIMA모형을 구축하고, 각 방법마다 모델링에 걸리는 시간을 측정 및 비교해 보도록 하겠습니다. 이번에도 역시 다른 일반적인 기법들과의 비교를 통해 속도 측정을 진행해 보도록 하죠.

library(forecast)

# 속도 측정용 데이터 생성 
test_range <- 1:50
testdata <- lapply(test_range, function(x){
 AirPassengers + sample(144)
}) %>%
 as.data.frame() %>%
 rename_with(~paste0('air', test_range))

glimpse(testdata)

#> Rows: 144
#> Columns: 50
#> $ air1 <dbl> 132, 217, 261, 156, 224, 242, 196, 233, 277, 177, 226, 133, 253,~
#> $ air2 <dbl> 235, 182, 168, 159, 203, 142, 191, 157, 146, 206, 185, 137, 131,~
#> $ air3 <dbl> 181, 140, 156, 218, 244, 263, 149, 259, 186, 237, 121, 257, 252,~
#> $ air4 <dbl> 160, 122, 146, 211, 164, 266, 180, 228, 139, 200, 141, 251, 172,~
#> $ air5 <dbl> 123, 241, 219, 204, 211, 277, 189, 211, 244, 123, 146, 194, 203,~
#> $ air6 <dbl> 251, 190, 265, 150, 187, 180, 255, 274, 276, 126, 138, 182, 207,~
#> $ air7 <dbl> 246, 211, 133, 175, 123, 188, 191, 255, 275, 183, 198, 241, 185,~
#> $ air8 <dbl> 199, 152, 135, 204, 245, 171, 171, 222, 188, 246, 144, 120, 175,~
#> $ air9 <dbl> 148, 198, 218, 161, 187, 158, 156, 208, 266, 126, 154, 132, 199,~
#> $ air10 <dbl> 209, 235, 160, 148, 137, 174, 261, 202, 171, 231, 191, 200, 206,~
#> $ air11 <dbl> 153, 148, 255, 221, 241, 276, 156, 170, 229, 247, 138, 217, 237,~
#> $ air12 <dbl> 171, 240, 180, 131, 245, 249, 227, 190, 162, 137, 121, 146, 179,~
#> $ air13 <dbl> 204, 121, 232, 198, 246, 256, 257, 274, 179, 172, 194, 230, 209,~
#> $ air14 <dbl> 180, 189, 271, 172, 185, 236, 258, 163, 144, 145, 170, 221, 162,~
#> $ air15 <dbl> 252, 191, 233, 149, 160, 263, 163, 175, 242, 130, 192, 159, 224,~
#> $ air16 <dbl> 162, 214, 247, 250, 174, 244, 205, 206, 259, 196, 211, 237, 197,~
#> $ air17 <dbl> 119, 246, 137, 142, 241, 246, 191, 174, 157, 171, 158, 179, 140,~
#> $ air18 <dbl> 122, 254, 166, 140, 245, 238, 254, 167, 153, 227, 135, 138, 243,~
#> $ air19 <dbl> 236, 190, 258, 230, 230, 180, 195, 245, 191, 230, 145, 231, 209,~
#> $ air20 <dbl> 136, 223, 246, 156, 169, 227, 285, 244, 178, 177, 159, 134, 175,~
#> $ air21 <dbl> 168, 245, 149, 164, 154, 140, 175, 259, 200, 149, 242, 241, 160,~
#> $ air22 <dbl> 114, 183, 212, 273, 199, 265, 217, 210, 248, 179, 133, 125, 166,~
#> $ air23 <dbl> 175, 253, 218, 146, 149, 155, 237, 166, 175, 253, 230, 159, 248,~
#> $ air24 <dbl> 247, 212, 238, 269, 177, 179, 250, 189, 225, 260, 109, 211, 202,~
#> $ air25 <dbl> 148, 200, 186, 246, 246, 138, 176, 220, 215, 252, 138, 167, 227,~
#> $ air26 <dbl> 125, 223, 215, 164, 231, 190, 151, 225, 199, 244, 129, 158, 162,~
#> $ air27 <dbl> 149, 237, 133, 133, 230, 137, 261, 232, 252, 190, 233, 144, 130,~
#> $ air28 <dbl> 142, 208, 227, 207, 245, 156, 219, 255, 177, 127, 209, 192, 183,~
#> $ air29 <dbl> 177, 221, 141, 156, 188, 207, 279, 186, 210, 141, 221, 223, 231,~
#> $ air30 <dbl> 135, 179, 210, 244, 179, 251, 290, 216, 270, 248, 145, 142, 178,~
#> $ air31 <dbl> 116, 195, 276, 134, 134, 144, 230, 201, 230, 169, 238, 147, 155,~
#> $ air32 <dbl> 232, 171, 267, 239, 144, 275, 179, 149, 186, 244, 156, 245, 143,~
#> $ air33 <dbl> 255, 228, 233, 218, 206, 168, 235, 243, 190, 230, 219, 180, 168,~
#> $ air34 <dbl> 187, 260, 233, 239, 265, 144, 161, 282, 191, 236, 217, 255, 206,~
#> $ air35 <dbl> 211, 137, 136, 186, 137, 204, 153, 161, 236, 212, 132, 246, 199,~
#> $ air36 <dbl> 145, 212, 224, 159, 135, 272, 221, 184, 280, 171, 135, 224, 199,~
#> $ air37 <dbl> 235, 214, 265, 212, 172, 245, 264, 220, 215, 169, 211, 188, 132,~
#> $ air38 <dbl> 229, 125, 182, 239, 224, 236, 273, 219, 144, 137, 141, 141, 129,~
#> $ air39 <dbl> 178, 139, 193, 183, 224, 191, 256, 150, 164, 251, 116, 215, 128,~
#> $ air40 <dbl> 122, 141, 133, 207, 185, 227, 206, 277, 237, 174, 160, 212, 175,~
#> $ air41 <dbl> 244, 203, 207, 223, 219, 218, 244, 170, 197, 189, 140, 141, 248,~
#> $ air42 <dbl> 202, 120, 223, 251, 257, 278, 258, 289, 183, 205, 176, 119, 132,~
#> $ air43 <dbl> 190, 152, 233, 252, 129, 242, 264, 149, 250, 218, 129, 140, 158,~
#> $ air44 <dbl> 156, 230, 198, 268, 221, 255, 215, 232, 235, 123, 152, 260, 198,~
#> $ air45 <dbl> 253, 194, 138, 209, 251, 199, 180, 229, 180, 171, 169, 195, 197,~
#> $ air46 <dbl> 125, 253, 178, 256, 147, 172, 217, 213, 226, 127, 113, 206, 139,~
#> $ air47 <dbl> 250, 165, 165, 163, 137, 249, 219, 281, 177, 193, 198, 138, 188,~
#> $ air48 <dbl> 241, 261, 220, 252, 148, 255, 157, 183, 274, 234, 225, 172, 184,~
#> $ air49 <dbl> 188, 128, 184, 176, 135, 226, 225, 266, 264, 167, 241, 142, 254,~
#> $ air50 <dbl> 115, 164, 151, 199, 241, 204, 273, 209, 184, 181, 155, 186, 152,~

# 시계열 데이터 변환 
testdata <- testdata %>% ts(frequency = 12, start = 1949)

# 모델링 속도 비교 
modeling_speed_test <- list()
modeling_speed_test <- list(
 # For문
 forLoop = system.time({
 for(i in seq(1, ncol(testdata))){
 testdata[, i] %>% auto.arima()
 }
 }),

 # lapply문
 lapply = system.time({
 testdata %>% lapply(auto.arima)
 }),

 # sapply문
 sapply = system.time({
 testdata %>% sapply(auto.arima)
 }),

 # `future` For문
 future_forLoop = system.time({
 for(i in seq(1, ncol(testdata))){
 future({
 testdata[, i] %>% auto.arima()
 })
 }
 }),

 # future_lapply문
 future_lapply = system.time({
 testdata %>% future_lapply(auto.arima)
 }),

 # future_map문
 future_map = system.time({
 testdata %>% future_map(auto.arima)
 }),

 #apply문 
 apply = system.time({
 testdata %>% apply(2, auto.arima)
 }),

 #future_apply문 
 future_apply = system.time({
 testdata %>% future_apply(2, auto.arima)
 })
)

modeling_speed_test

#> $forLoop
#> 사용자 시스템 elapsed
#> 260.25 0.37 261.09
#>
#> $lapply
#> 사용자 시스템 elapsed
#> 257.83 0.06 258.26
#>
#> $sapply
#> 사용자 시스템 elapsed
#> 268.69 0.13 269.25
#>
#> $future_forLoop
#> 사용자 시스템 elapsed
#> 0.98 0.01 96.67
#>
#> $future_lapply
#> 사용자 시스템 elapsed
#> 1.41 0.02 113.04
#>
#> $future_map
#> 사용자 시스템 elapsed
#> 0.64 0.02 4.21
#>
#> $apply
#> 사용자 시스템 elapsed
#> 6.67 0.00 6.72
#>
#> $future_apply
#> 사용자 시스템 elapsed
#> 0.47 0.01 2.31

50번에 걸친 ARIMA모델링을 sapply() 함수가 269.25초 동안 처리한 것에 비해 future_apply() 함수는 2초 내외의 시간 안에 처리한 것을 확인할 수 있습니다. 이와 같이 future 패키지를 통한 비동기 및 병렬연산을 적절히 활용한다면 보다 빠르고 효율적인 R 프로그래밍을 진행 할 수 있습니다.

참고자료

[R] Rstudio의 테마를 변경해 사용하기(With rsthemes Package)

Sat, 24 Oct 2020 00:00:00 +0000

데이터분석 혹은 R프로그래밍을 진행할 때 가장 많이 보는것이 (아마도) 구글, 스택오버플로우, 그리고 Rstudio일 것입니다.대다수의 R 유저들은 사용하는 IDE로서 Rstudio 를 선호하는데요. 저 역시도 Rstudio에서 제공하는 각종 편의기능에 익숙해져 vscode와 같은 다른 IDE로 쉽사리 넘어가지 못하는것 같습니다. 그러나 오랜시간 비슷한 화면만을 보다보면 제아무리 만족스럽던 것도 점차 지루해지기 쉽상입니다. 이럴때 약간의 변화만 주어도 한결 나은 코딩을 할 수 있을텐데요. 오늘은 Rstudio에서 제공하는 기본테마를 벗어나 새롭고 다양한 테마를 제공할 뿐만아니라 테마변경을 손쉽게 하는 패키지를 소개하고자 합니다.

기본 테마 변경

Rstudio를 처음 설치하면 4개의 패널로 나뉜 흰색의 기본 테마를 마주치게 됩니다. 기본 테마 역시 멋지지만 오랜시간 흰색의 배경을 응시하다보면 눈이 쉽사리 피로해지곤 하기때문에 많은 분들이 개발환경에 있어서 밝은것보다 어두운 테마를 더욱 선호하는것 같습니다. 먼저 기본적인 Rstudio의 테마의 변경은 상단의 Tools > Global Options > Appearence 탭을 통해 변경이 가능합니다.

기본 테마 변경 과정

rsthemes package

기본적으로 제공되는 테마가 불충분하다고 느껴지신다면 이 패키지가 도움이 될 수도 있습니다. 서두에서도 소개했다시피 패키지는 Rstudio에서 사용할 수 있는 90여가지의 추가적인 테마를 제공합니다.

설치

는 cran에 정식으로 등록되지 않은 패키지이기 때문에 개발자 깃헙 레포지터리에서 다운받을 수 있습니다.

# install.packages("devtools")
devtools::install_github("gadenbuie/rsthemes")

패키지를 다운받은 후, 추가 테마를 설치합니다.

rsthemes::install_rsthemes()

base16테마를 설치하는 옵션을 지정하면 더욱 많은 테마를 설치할 수 있습니다.

rsthemes::install_rsthemes(include_base16 = TRUE)

사용

패키지와 테마의 설치까지 마치셨다면 에서 제공하는 함수들을 통해 테마를 관리 할 수 있습니다. 맨 먼저 설치된 테마의 목록들을 확인합니다.

# 설치된 테마의 목록 확인
rsthemes::list_rsthemes()
# [1] "a11y-dark {rsthemes}" 
# [2] "a11y-light {rsthemes}" 
# [3] "base16 3024 {rsthemes}" 
# [4] "base16 Apathy {rsthemes}" 
# [5] "base16 Ashes {rsthemes}" 
# [6] "base16 Atelier Cave {rsthemes}" 
# [7] "base16 Atelier Dune {rsthemes}" 
# [8] "base16 Atelier Estuary {rsthemes}" 
# [9] "base16 Atelier Forest {rsthemes}" 
# [10] "base16 Atelier Heath {rsthemes}" 
# [11] "base16 Atelier Lakeside {rsthemes}" 
# [12] "base16 Atelier Plateau {rsthemes}" 
# [13] "base16 Atelier Savanna {rsthemes}" 
# [14] "base16 Atelier Seaside {rsthemes}" 
# [15] "base16 Atelier Sulphurpool {rsthemes}" 
# [16] "base16 Bespin {rsthemes}" 
# [17] "base16 Brewer {rsthemes}" 
# [18] "base16 Bright {rsthemes}" 
# [19] "base16 Chalk {rsthemes}" 
# [20] "base16 Codeschool {rsthemes}" 
# [21] "base16 Cupcake {rsthemes}" 
# [22] "base16 Darktooth {rsthemes}" 
# [23] "base16 Default Dark {rsthemes}" 
# [24] "base16 Default Light {rsthemes}" 
# [25] "base16 Dracula {rsthemes}" 
# [26] "base16 Eighties {rsthemes}" 
# [27] "base16 Embers {rsthemes}" 
# [28] "base16 Flat {rsthemes}" 
# [29] "base16 Google Dark {rsthemes}" 
# [30] "base16 Google Light {rsthemes}" 
# [31] "base16 Grayscale Dark {rsthemes}" 
# [32] "base16 Grayscale Light {rsthemes}" 
# [33] "base16 Green Screen {rsthemes}" 
# [34] "base16 Gruvbox dark, hard {rsthemes}" 
# [35] "base16 Gruvbox dark, medium {rsthemes}" 
# [36] "base16 Gruvbox dark, pale {rsthemes}" 
# [37] "base16 Gruvbox dark, soft {rsthemes}" 
# [38] "base16 Gruvbox light, hard {rsthemes}" 
# [39] "base16 Gruvbox light, medium {rsthemes}"
# [40] "base16 Gruvbox light, soft {rsthemes}" 
# [41] "base16 Harmonic16 Dark {rsthemes}" 
# [42] "base16 Harmonic16 Light {rsthemes}" 
# [43] "base16 Hopscotch {rsthemes}" 
# [44] "base16 IR Black {rsthemes}" 
# [45] "base16 Isotope {rsthemes}" 
# [46] "base16 London Tube {rsthemes}" 
# [47] "base16 Macintosh {rsthemes}" 
# [48] "base16 Marrakesh {rsthemes}" 
# [49] "base16 Materia {rsthemes}" 
# [50] "base16 Mexico Light {rsthemes}" 
# [51] "base16 Mocha {rsthemes}" 
# [52] "base16 Monokai {rsthemes}" 
# [53] "base16 Nord {rsthemes}" 
# [54] "base16 Ocean {rsthemes}" 
# [55] "base16 OceanicNext {rsthemes}" 
# [56] "base16 OneDark {rsthemes}" 
# [57] "base16 Paraiso {rsthemes}" 
# [58] "base16 PhD {rsthemes}" 
# [59] "base16 Pico {rsthemes}" 
# [60] "base16 Pop {rsthemes}" 
# [61] "base16 Railscasts {rsthemes}" 
# [62] "base16 Rebecca {rsthemes}" 
# [63] "base16 Seti UI {rsthemes}" 
# [64] "base16 Shapeshifter {rsthemes}" 
# [65] "base16 Solar Flare {rsthemes}" 
# [66] "base16 Solarized Dark {rsthemes}" 
# [67] "base16 Solarized Light {rsthemes}" 
# [68] "base16 Spacemacs {rsthemes}" 
# [69] "base16 Summerfruit Dark {rsthemes}" 
# [70] "base16 Summerfruit Light {rsthemes}" 
# [71] "base16 Tomorrow Night {rsthemes}" 
# [72] "base16 Tomorrow {rsthemes}" 
# [73] "base16 Twilight {rsthemes}" 
# [74] "base16 Unikitty Dark {rsthemes}" 
# [75] "base16 Unikitty Light {rsthemes}" 
# [76] "base16 Woodland {rsthemes}" 
# [77] "Fairyfloss {rsthemes}" 
# [78] "Flat White {rsthemes}" 
# [79] "GitHub {rsthemes}" 
# [80] "Nord Polar Night Aurora {rsthemes}" 
# [81] "Nord Snow Storm {rsthemes}" 
# [82] "Oceanic Plus {rsthemes}" 
# [83] "One Dark {rsthemes}" 
# [84] "One Light {rsthemes}" 
# [85] "Solarized Dark {rsthemes}" 
# [86] "Solarized Light {rsthemes}"

다음의 함수를 통해 설치된 테마들을 하나씩 적용 할 수 있습니다.

# 테마 적용하기 
rsthemes::try_rsthemes()
# light, dark, base16 themes를 선택적으로 적용하기 
rsthemes::try_rsthemes("light")

rstudioapi::applyTheme()를 사용하면 목록의 테마를 하나씩 적용할 수 있습니다.

# 특정 테마 적용하기 
rstudioapi::applyTheme("One Dark {rsthemes}")

손 쉽게 테마 변경하기

패키지가 가진 가장 큰 강점이 여기에 있습니다. 기호에 맞는 테마를 저장하고, 이를 단축키로 등록시켜 손 쉽게 테마를 전환시킬 수 있는 기능을 지원하는데요. 이 기능을 사용하기 위해선 먼저 자신이 선호하는 테마를 등록해야 합니다.

주-야간 테마

rsthemes::set_theme_light(), rsthemes::set_theme_dark()함수는 각각 밝은 테마, 어두운 테마 하나씩을 지정할 수 있습니다.

# 현재 사용중인 테마를 주-야간 테마로 설정하기 
rsthemes::set_theme_light()
rsthemes::set_theme_dark()

# 특정 테마를 주-야간 테마로 등록하기 
rsthemes::set_theme_light("One Light {rsthemes}")
rsthemes::set_theme_dark("One Dark {rsthemes}")

즐겨찾는 테마

rsthemes::set_theme_favorite()함수를 통해 자신이 선호하는 테마 등록이 가능합니다.

# 현재 사용중인 테마를 선호테마목록에 추가 
rsthemes::set_theme_favorite()

# 다수의 테마 선호테마목록에 추가 
rsthemes::set_theme_favorite(
 c("GitHub {rsthemes}", "One Light {rsthemes}", "One Dark {rsthemes}")
)

기본 세션에 등록

위의 함수들을 통해 선호하는 테마를 지정하였습니다. 하지만 이 설정은 오직 현재 세션에만 저장이 되기 때문에 만약 Rstudio를 종료 후 다시 키거나 혹은 새로운 세션으로 접속하면 사라질 정보입니다. 때문에 기본 세션에 등록을 시켜야지만 지속적으로 사용이 가능합니다. usethis::edit_r_profile()함수를 통해 ~/.Rprofile을 편집하여 등록한 테마를 모든 세션에서 사용 가능하도록 설정합니다.

# ~/.Rprofile
if (interactive()) {
 rsthemes::set_theme_light("GitHub {rsthemes}")
 rsthemes::set_theme_dark("Fairyfloss {rsthemes}")
 rsthemes::set_theme_favorite(
 c("GitHub {rsthemes}",
 "One Light {rsthemes}",
 "One Dark {rsthemes}")
 )
}

단축키 등록

~/.Rprofile파일에 테마를 등록하여 저장하면 세션이 종료되거나 바뀌어도 설정은 날아가지 않습니다. 이번엔 저장된 테마를 스위칭하는 단축키를 설정하는 방법에 대해 알아보겠습니다. 패키지는 세가지 addins 기능을 지원합니다.

Toggle Dark Mode : 주-야간 테마
Favorite Themes : 즐겨찾는 테마
Auto Dark Mode : 주-야간 테마 지정된 시간에 자동 변경

addins에 들어가있는 기능들은 기본적으로 Rstudio의 단축키로 설정이 가능합니다. 이 말인 즉슨 테마전환기능을 단축키로 지정해서 사용하는게 가능하다는 의미인데요. Rstudio의 단축키는 Tools > Modify Keyboard shortcuts에서 설정 할 수 있습니다.

검색란에 ’toggle’만 타이핑해도 “Toggle Dark Mode"이 자동완성으로 등장합니다. 이곳에 원하는 단축키를 등록합니다. 저는 단축키로 “Ctrl+Alt+D"를 등록하였습니다.

이후 설정한 단축키를 누르면 주-야간테마로 전환되는 것을 확인할 수 있을 겁니다. 즐겨찾는 테마의 단축키 등록도 이와 동일한 방식으로 등록이 가능하므로 똑같은 방식이니 추가적인 설명은 생략하고 넘어가도록 하겠습니다. (단축키로 “Ctrl+Alt+N"을 추천합니다.)

addins의 마지막 기능인 Auto Dark Mode를 활성화하면 Rstudio가 정해진 시간에 맞춰서 주간테마, 야간테마를 자동으로 전환됩니다 직접 테마를 바꾸거나 단축키 등록을 하지 않더라도 이것만 설정하면 낮과 밤에 따라 테마를 변경시킬 수 있는데요. 이 기능은 단축키 등록이 아닌 아까 살펴봤던 ~/.Rprofile의 수정을 통해 가능합니다. 콘솔창에 다시 한번 usethis::edit_r_profile()함수를 입력합니다.

# ~/.Rprofile
if (interactive()) {
 rsthemes::set_theme_light("GitHub {rsthemes}") # 주간 테마 
 rsthemes::set_theme_dark("Fairyfloss {rsthemes}") # 야간 테마 
 rsthemes::set_theme_favorite( # 즐겨찾는 테마 
 c("GitHub {rsthemes}",
 "One Light {rsthemes}",
 "One Dark {rsthemes}")
 )

 # 주-야간 테마 지정된 시간에 자동 변경
 setHook("rstudio.sessionInit", function(isNewSession) {
 rsthemes::use_theme_auto(dark_start = as.POSIXct('17:00',format="%H:%M"), dark_end = as.POSIXct('09:00',format="%H:%M"))
 }, action = "append")
}

~/.Rprofile에 ‘주-야간 테마 지정된 시간에 자동 변경’ 코드를 추가하였습니다. 만약 이와 같이 설정하면 17:00에 자동으로 야간테마로 전환되고, 다음날 09:00가 되면 주간 테마로 전환될 것입니다. 함수 내부에 as.POSIXct()값을 조정하여 테마가 전환되는 시간을 조정할 수 있습니다.

참고자료

[R] stringr 패키지를 사용한 정규표현식

Sat, 03 Oct 2020 00:00:00 +0000

이전 장에서 R에서 사용되는 정규표현식에 대해 알아보았었는데요. 오늘은 정규표현식을 텍스트 데이터를 처리할때 사용하는 패키지인 stringr 과 함께 사용하는 방법에 대해 알아보도록 하겠습니다.

stringr

stringr 패키지는 Rstudio의 Hadley Wickham이 개발한 패키지입니다. dplyr , ggplot2 등과 같이 데이터를 깔끔한(tidy) 방식으로 처리하는것을 지향하는 tidyverse 패키지군에 속해 있으며, 그 중 stringr 은 문자열 처리에 특화된 패키지입니다. ‘string’의 준말인 str_이 함수 머릿말에 항상 등장하는 것이 특징입니다.

stringr 패키지의 주요 기능을 아래와 같이 분류하였고 각 경우에 맞는 상황을 가정하여 알아보도록 하겠습니다.

예제 문장

연습용으로 사용할 문장은 stringr 패키지에 내장되어 있는 sentence 데이터를 사용하겠습니다. sentence는 총 1000문장으로 구성되어 있는데, 문장 전체를 사용할 필요가 없으므로 10문장 정도만을 추려서 사용하도록 하겠습니다.

regex_sentences <- stringr::sentences[1:10] # 예제용 문장 생성

regex_sentences
#> [1] "The birch canoe slid on the smooth planks." 
#> [2] "Glue the sheet to the dark blue background."
#> [3] "It's easy to tell the depth of a well." 
#> [4] "These days a chicken leg is a rare dish." 
#> [5] "Rice is often served in round bowls." 
#> [6] "The juice of lemons makes fine punch." 
#> [7] "The box was thrown beside the parked truck."
#> [8] "The hogs were fed chopped corn and garbage."
#> [9] "Four hours of steady work faced us." 
#> [10] "Large size in stockings is hard to sell."

일치

str_detect()함수는 특정 문자 혹은 패턴(정규표현식)과 일치하는 경우를 찾을때 사용하며, 실행 결과로서 boolean(참, 거짓)을 반환합니다.

str_detect(regex_sentences, '[aeiou]') # 알파벳 모음 'a' or 'e' or 'i' or 'o' or 'u'가 있을 경우 TRUE
#> [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE

str_detect(regex_sentences, '[easy]') # 알파벳 'e' or 'a' or 's' or 'y'가 있을 경우 TRUE 
#> [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE

str_detect(regex_sentences, '(easy)') # 알파벳 'easy'가 있을 경우 TRUE 
#> [1] FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE

str_extract()함수는 특정 문자 혹은 패턴(정규표현식)과 일치하는 경우, 그것을 반환합니다.

str_extract(regex_sentences, '[aeiou]') # 'a' or 'e' or 'i' or 'o' or 'u' 글자가 존재하면 그것을 반환 
#> [1] "e" "u" "e" "e" "i" "e" "e" "e" "o" "a"

str_extract(regex_sentences, '[:punct:]') # 문장부호가 존재하면 그것을 반환 
#> [1] "." "." "'" "." "." "." "." "." "." "."

함수는 조건에 일치하는 결과를 반환하였는데요. 자세히 보면 조건에 일치한 것이 여러개 있음에도 불구하고 오직 최초 값만을 반환하는 것을 볼 수 있습니다. 그렇다면 조건에 일치하는 모든 값을 찾고자 할 땐 어떻게 해야할까요? 바로 str_extract_all() 함수를 사용하면 됩니다. stringr 패키지 함수 중 몇몇의 함수는 함수 말미에 _all이 붙는 함수들이 있습니다. 이들 함수들은 조건에 맞는 모든 값을 반환하는 특징이 있습니다.

str_extract_all(regex_sentences, '[aeiou]')
#> [[1]]
#> [1] "e" "i" "a" "o" "e" "i" "o" "e" "o" "o" "a"
#> 
#> [[2]]
#> [1] "u" "e" "e" "e" "e" "o" "e" "a" "u" "e" "a" "o" "u"
#> 
#> [[3]]
#> [1] "e" "a" "o" "e" "e" "e" "o" "a" "e"
#> 
#> [[4]]
#> [1] "e" "e" "a" "a" "i" "e" "e" "i" "a" "a" "e" "i"
#> 
#> [[5]]
#> [1] "i" "e" "i" "o" "e" "e" "e" "i" "o" "u" "o"
#> 
#> [[6]]
#> [1] "e" "u" "i" "e" "o" "e" "o" "a" "e" "i" "e" "u"
#> 
#> [[7]]
#> [1] "e" "o" "a" "o" "e" "i" "e" "e" "a" "e" "u"
#> 
#> [[8]]
#> [1] "e" "o" "e" "e" "e" "o" "e" "o" "a" "a" "a" "e"
#> 
#> [[9]]
#> [1] "o" "u" "o" "u" "o" "e" "a" "o" "a" "e" "u"
#> 
#> [[10]]
#> [1] "a" "e" "i" "e" "i" "o" "i" "i" "a" "o" "e"

str_extract_all(regex_sentences, '[:punct:]')
#> [[1]]
#> [1] "."
#> 
#> [[2]]
#> [1] "."
#> 
#> [[3]]
#> [1] "'" "."
#> 
#> [[4]]
#> [1] "."
#> 
#> [[5]]
#> [1] "."
#> 
#> [[6]]
#> [1] "."
#> 
#> [[7]]
#> [1] "."
#> 
#> [[8]]
#> [1] "."
#> 
#> [[9]]
#> [1] "."
#> 
#> [[10]]
#> [1] "."

str_extract_all() 함수의 결과, 조건에 부합하는 모든 값이 list 형으로 반환된 것을 볼 수 있습니다.

카운팅

str_count()함수는 특정 문자 혹은 패턴(정규표현식)과 일치하는 경우를 계산합니다.

str_count(regex_sentences, '[aeiou]') # 'a' or 'e' or 'i' or 'o' or 'u' 문자의 개수를 반환 
#> [1] 11 13 9 12 11 12 11 12 11 11

str_count(regex_sentences, '^(The)') # 시작이 'The'인 경우를 셈 
#> [1] 1 0 0 1 0 1 1 1 0 0

포함

str_subset()함수는 특정 문자 혹은 패턴(정규표현식)이 포함된 경우를 반환합니다.

str_subset(regex_sentences, '[aeiou]') # 'a' or 'e' or 'i' or 'o' or 'u' 문자가 포함된 경우를 반환 
#> [1] "The birch canoe slid on the smooth planks." 
#> [2] "Glue the sheet to the dark blue background."
#> [3] "It's easy to tell the depth of a well." 
#> [4] "These days a chicken leg is a rare dish." 
#> [5] "Rice is often served in round bowls." 
#> [6] "The juice of lemons makes fine punch." 
#> [7] "The box was thrown beside the parked truck."
#> [8] "The hogs were fed chopped corn and garbage."
#> [9] "Four hours of steady work faced us." 
#> [10] "Large size in stockings is hard to sell."

str_subset(regex_sentences, '^(The)') # 시작이 'The'인 문장을 반환
#> [1] "The birch canoe slid on the smooth planks." 
#> [2] "These days a chicken leg is a rare dish." 
#> [3] "The juice of lemons makes fine punch." 
#> [4] "The box was thrown beside the parked truck."
#> [5] "The hogs were fed chopped corn and garbage."

str_subset(regex_sentences, 'p[:alpha:]{1,}\\.$') # 'p'뒤에 알파벳이 한번 이상 나오면서 마침표로 끝나는 경우 
#> [1] "The birch canoe slid on the smooth planks."
#> [2] "The juice of lemons makes fine punch."

위치

str_locate()함수는 특정 문자 혹은 패턴(정규표현식)에 맞는 경우의 시작 지점과 끝 지점을 반환합니다. R에 기본적으로 내장되어 있는 영어 소문자 데이터인 letters를 통해 알아보겠습니다.

letters
#> [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
#> [20] "t" "u" "v" "w" "x" "y" "z"

패턴의 위치를 찾기 위해선 하나로 묶인 데이터가 필요하므로 str_c() 함수를 사용하여 하나의 벡터로 묶었습니다. (str_c()함수는 __stringr__패키지의 문자를 결합하는 함수. R의 내장함수인 paste()와 동일하게 동작)

letters <- str_c(letters, collapse = '');

letters # 하나의 벡터값으로 변환 
#> [1] "abcdefghijklmnopqrstuvwxyz"

str_locate(letters, '[a-z]+') # 'a'부터 'z' 까지의 문자가 한개 이상 나오는 경우의 시작과 끝을 반환 
#> start end
#> [1,] 1 26

str_locate(letters, '^[a][a-z]+[z]$') # 시작이 'a'이며, 바로 뒤에 'a' 부터 'z'까지의 문자 중 하나가 한번 이상 나오며, 끝이 'z'인 경우의 시작 지점과 끝 지점을 반환.
#> start end
#> [1,] 1 26

str_locate(letters, '^[a-z][a-z]+$') # 시작이 'a' 부터 'z' 까지의 문자 중 하나이며, 끝이 'a' 부터 'z' 까지의 문자 중 하나인 경우의 시작 지점과 끝 지점.
#> start end
#> [1,] 1 26

str_locate(letters, '(abcde)') # 'abcde'의 시작 지점과 끝 지점을 반환 
#> start end
#> [1,] 1 5

str_locate(letters, '(xyz)') # 'xyz'의 시작 지점과 끝 지점을 반환 
#> start end
#> [1,] 24 26

str_locate_all()함수를 통해 조건에 맞는 모든 값의 위치를 추출할 수 있습니다.

str_locate(letters, '[aeiou][^aeiou]+') # 'a' or 'e' or 'i' or 'o' or 'u'문자 뒤에 'a' or 'e' or 'i' or 'o' or 'u' 문자가 아닌 문자가 하나 이상 나오는 최초 경우의 시작 지점과 끝 지점을 반환 
#> start end
#> [1,] 1 4

str_locate_all(letters, '[aeiou][^aeiou]+') # 'a' or 'e' or 'i' or 'o' or 'u'문자 뒤에 'a' or 'e' or 'i' or 'o' or 'u' 문자가 아닌 문자가 하나 이상 나오는 모든 경우의 시작 지점과 끝 지점을 반환 
#> [[1]]
#> start end
#> [1,] 1 4
#> [2,] 5 8
#> [3,] 9 14
#> [4,] 15 20
#> [5,] 21 26

바꾸기

str_replace()는 특정 문자 혹은 패턴(정규표현식)에 맞는 경우를 새로운 문자로 바꾸는 함수입니다.

str_replace(regex_sentences, 'k', "'K'") # 최초로 매칭되는 문자 k를 'K'로 변환 
#> [1] "The birch canoe slid on the smooth plan'K's." 
#> [2] "Glue the sheet to the dar'K' blue background."
#> [3] "It's easy to tell the depth of a well." 
#> [4] "These days a chic'K'en leg is a rare dish." 
#> [5] "Rice is often served in round bowls." 
#> [6] "The juice of lemons ma'K'es fine punch." 
#> [7] "The box was thrown beside the par'K'ed truck."
#> [8] "The hogs were fed chopped corn and garbage." 
#> [9] "Four hours of steady wor'K' faced us." 
#> [10] "Large size in stoc'K'ings is hard to sell."

str_replace(regex_sentences, '\\.', '\\?') # 최초로 매칭되는 마침표를 물음표로 변환 
#> [1] "The birch canoe slid on the smooth planks?" 
#> [2] "Glue the sheet to the dark blue background?"
#> [3] "It's easy to tell the depth of a well?" 
#> [4] "These days a chicken leg is a rare dish?" 
#> [5] "Rice is often served in round bowls?" 
#> [6] "The juice of lemons makes fine punch?" 
#> [7] "The box was thrown beside the parked truck?"
#> [8] "The hogs were fed chopped corn and garbage?"
#> [9] "Four hours of steady work faced us?" 
#> [10] "Large size in stockings is hard to sell?"

마찬가지로 str_replace_all()함수를 통해 조건에 맞는 모든 값을 바꿀 수 있습니다.

str_replace(regex_sentences, '[:alpha:]{1,}', 'word') # 최초로 매칭되는 알파뱃이 한개 이상인 경우를 'word'로 변환 
#> [1] "word birch canoe slid on the smooth planks." 
#> [2] "word the sheet to the dark blue background." 
#> [3] "word's easy to tell the depth of a well." 
#> [4] "word days a chicken leg is a rare dish." 
#> [5] "word is often served in round bowls." 
#> [6] "word juice of lemons makes fine punch." 
#> [7] "word box was thrown beside the parked truck."
#> [8] "word hogs were fed chopped corn and garbage."
#> [9] "word hours of steady work faced us." 
#> [10] "word size in stockings is hard to sell."

str_replace_all(regex_sentences, '[:alpha:]{1,}', 'word') # 알파뱃이 한개 이상인 모든 값을 'word'라는 단어로 변환 
#> [1] "word word word word word word word word." 
#> [2] "word word word word word word word word." 
#> [3] "word'word word word word word word word word word."
#> [4] "word word word word word word word word word." 
#> [5] "word word word word word word word." 
#> [6] "word word word word word word word." 
#> [7] "word word word word word word word word." 
#> [8] "word word word word word word word word." 
#> [9] "word word word word word word word." 
#> [10] "word word word word word word word word."

str_replace(regex_sentences, '[:space:]', '') # 최초로 매칭되는 띄어쓰기를 공백으로 변환 
#> [1] "Thebirch canoe slid on the smooth planks." 
#> [2] "Gluethe sheet to the dark blue background."
#> [3] "It'seasy to tell the depth of a well." 
#> [4] "Thesedays a chicken leg is a rare dish." 
#> [5] "Riceis often served in round bowls." 
#> [6] "Thejuice of lemons makes fine punch." 
#> [7] "Thebox was thrown beside the parked truck."
#> [8] "Thehogs were fed chopped corn and garbage."
#> [9] "Fourhours of steady work faced us." 
#> [10] "Largesize in stockings is hard to sell."

str_replace_all(regex_sentences, '[:space:]', '') # 매칭되는 모든 띄어쓰기를 공백으로 변환 
#> [1] "Thebirchcanoeslidonthesmoothplanks." 
#> [2] "Gluethesheettothedarkbluebackground."
#> [3] "It'seasytotellthedepthofawell." 
#> [4] "Thesedaysachickenlegisararedish." 
#> [5] "Riceisoftenservedinroundbowls." 
#> [6] "Thejuiceoflemonsmakesfinepunch." 
#> [7] "Theboxwasthrownbesidetheparkedtruck."
#> [8] "Thehogswerefedchoppedcornandgarbage."
#> [9] "Fourhoursofsteadyworkfacedus." 
#> [10] "Largesizeinstockingsishardtosell."

나누기

str_split()는 특정 문자 혹은 패턴(정규표현식)을 기준으로 값을 나누는 함수입니다. 이때 기준이된 문자 혹은 패턴은 제거됩니다.

str_split(regex_sentences, '[:upper:]') # 대문자를 기준으로 분절 
#> [[1]]
#> [1] "" 
#> [2] "he birch canoe slid on the smooth planks."
#> 
#> [[2]]
#> [1] "" 
#> [2] "lue the sheet to the dark blue background."
#> 
#> [[3]]
#> [1] "" 
#> [2] "t's easy to tell the depth of a well."
#> 
#> [[4]]
#> [1] "" 
#> [2] "hese days a chicken leg is a rare dish."
#> 
#> [[5]]
#> [1] "" "ice is often served in round bowls."
#> 
#> [[6]]
#> [1] "" 
#> [2] "he juice of lemons makes fine punch."
#> 
#> [[7]]
#> [1] "" 
#> [2] "he box was thrown beside the parked truck."
#> 
#> [[8]]
#> [1] "" 
#> [2] "he hogs were fed chopped corn and garbage."
#> 
#> [[9]]
#> [1] "" "our hours of steady work faced us."
#> 
#> [[10]]
#> [1] "" 
#> [2] "arge size in stockings is hard to sell."

str_split(regex_sentences, '\\b') # 문자의 바운더리를 기준으로 분절 
#> [[1]]
#> [1] "" "The" " " "birch" " " "canoe" " " "slid" 
#> [9] " " "on" " " "the" " " "smooth" " " "planks"
#> [17] "." 
#> 
#> [[2]]
#> [1] "" "Glue" " " "the" " " 
#> [6] "sheet" " " "to" " " "the" 
#> [11] " " "dark" " " "blue" " " 
#> [16] "background" "." 
#> 
#> [[3]]
#> [1] "" "It" "'" "s" " " "easy" " " "to" " " 
#> [10] "tell" " " "the" " " "depth" " " "of" " " "a" 
#> [19] " " "well" "." 
#> 
#> [[4]]
#> [1] "" "These" " " "days" " " "a" " " 
#> [8] "chicken" " " "leg" " " "is" " " "a" 
#> [15] " " "rare" " " "dish" "." 
#> 
#> [[5]]
#> [1] "" "Rice" " " "is" " " "often" " " "served"
#> [9] " " "in" " " "round" " " "bowls" "." 
#> 
#> [[6]]
#> [1] "" "The" " " "juice" " " "of" " " "lemons"
#> [9] " " "makes" " " "fine" " " "punch" "." 
#> 
#> [[7]]
#> [1] "" "The" " " "box" " " "was" " " "thrown"
#> [9] " " "beside" " " "the" " " "parked" " " "truck" 
#> [17] "." 
#> 
#> [[8]]
#> [1] "" "The" " " "hogs" " " "were" " " 
#> [8] "fed" " " "chopped" " " "corn" " " "and" 
#> [15] " " "garbage" "." 
#> 
#> [[9]]
#> [1] "" "Four" " " "hours" " " "of" " " "steady"
#> [9] " " "work" " " "faced" " " "us" "." 
#> 
#> [[10]]
#> [1] "" "Large" " " "size" " " "in" 
#> [7] " " "stockings" " " "is" " " "hard" 
#> [13] " " "to" " " "sell" "."

str_split(regex_sentences, '\\s') # 띄어쓰기를 기준으로 분절 
#> [[1]]
#> [1] "The" "birch" "canoe" "slid" "on" "the" "smooth" 
#> [8] "planks."
#> 
#> [[2]]
#> [1] "Glue" "the" "sheet" "to" "the" 
#> [6] "dark" "blue" "background."
#> 
#> [[3]]
#> [1] "It's" "easy" "to" "tell" "the" "depth" "of" "a" "well."
#> 
#> [[4]]
#> [1] "These" "days" "a" "chicken" "leg" "is" "a" 
#> [8] "rare" "dish." 
#> 
#> [[5]]
#> [1] "Rice" "is" "often" "served" "in" "round" "bowls."
#> 
#> [[6]]
#> [1] "The" "juice" "of" "lemons" "makes" "fine" "punch."
#> 
#> [[7]]
#> [1] "The" "box" "was" "thrown" "beside" "the" "parked" "truck."
#> 
#> [[8]]
#> [1] "The" "hogs" "were" "fed" "chopped" "corn" "and" 
#> [8] "garbage."
#> 
#> [[9]]
#> [1] "Four" "hours" "of" "steady" "work" "faced" "us." 
#> 
#> [[10]]
#> [1] "Large" "size" "in" "stockings" "is" "hard" 
#> [7] "to" "sell."

참고자료

[R] 정규표현식 활용한 텍스트 데이터 다루기

Fri, 02 Oct 2020 00:00:00 +0000

문자형 데이터를 다루는데는 수 많은 기법들이 있습니다. R에서 제공하는 기본 함수들을 통해 처리하기도 하고, 텍스트처리에 특화된 패키지함수를 사용하여 원하는 처리를 할 수 있는데요. 오늘은 그 중에 텍스트데이터를 다루는데 효과적으로 사용되는 정규표현식을 사용하는 법에 대해 알아보도록 하겠습니다.

정규표현식

정규표현식(regular expression)은 특정한 규칙을 가진 문자열의 집합을 표현하는데 사용하는 형식 언어입니다. 프로그래밍에서 조건문과 반복문을 통해 원하는 결과값을 도출해내는 것처럼, 텍스트데이터에서 조건과 패턴에 맞는 문자열을 찾거나 추출할때 정규식을 사용합니다. 정규표현식에는 특별한 의미를 지니고 있는 메타문자 와 문자 그대로의 의미를 지닌 일반문자 로 구성되어 있습니다.

메타문자

메타문자는 정규표현식에서 특별한 의미를 갖는 문자 기호입니다. 키보드에서 알파벳과 숫자를 제외한 특수 기호중에서 미리 정의한 기능을 가진 기호들을 메타문자라고 합니다. ! + \ & ^ [] ~ 등의 문자들이 메타 문자이며 이들은 각각 부여받은 기능들이 있어 이를 조합하여 특정한 패턴을 정의하는 방식으로 사용됩니다.

이해를 돕기위해 예시와 함께 살펴보도록 하겠습니다.

정규표현식 사용자 함수 생성

R Studio의 stringr 패키지 Cheat Sheet에 좋은 예시함수가 있어서 이를 차용하였습니다. 정규표현식 조건에 맞는 문자는 음영처리되어 보여집니다.

see <- function(rx) str_view_all("abc ABC 123\t.!?\\(){}\n abcde aaa bacad .a.aa.aaa abbaab ababcbabcdcbabcde", rx)

“^”

^(윗꺽쇠)는 문자열의 시작지점을 의미합니다.

see('^') # 문자열의 시작지점을 매칭

“$”

$(달러표시)는 문자열의 끝 또는 문서의 끝을 의미합니다.

see('$') # 문자열의 끝지점을 매칭

“.”

.(마침표)는 임의의 한 글자를 의미합니다.

see('.') # 임의의 글자를 매칭

다른 규칙없이 마침표만을 단독으로 사용하니 임의의 모든 글자가 선택되었습니다.

“?”

?(물음표)는 앞에 지정된 문자가 없거나 하나가 있음을 의미합니다.

see('?')

#> Error in stri_locate_all_regex(string, pattern, omit_no_match = TRUE, : Syntax error in regexp pattern. (U_REGEX_RULE_SYNTAX, context=`?`)

물음표를 단독으로 사용하니 에러가 발생하였습니다. 이는 물음표 조건에 맞지 않기 때문입니다. ‘ab?c’(a와 c 사이에 b가 하나 있거나 아니면 아예 없거나) 조건으로 설정해보겠습니다.

see('ab?c') # 'a'와 'c' 사이에 'b'가 하나 있거나 혹은 아예 없는 경우 ('abc' or 'ac')

정규표현식은 대소문자를 구분하기 때문에 소문자 ’abc’와 ’ac’가 선택된 것을 볼 수 있습니다. 정규표현식의 규칙은 매우 엄격하게 지켜지기 때문에 정규표현을 사용할 때는 정확한 규칙을 만들어서 사용할 필요가 있습니다.

“|”

|(또는)은 의미 그대로 또는을 의미합니다. | 기호를 기준으로 좌우에 해당하는 문자들을 찾습니다.

see('a|c') # 'a' 또는 'c'를 찾아냄

“+”

+(더하기)는 앞 문자가 1개이상인 경우를 의미합니다. + 기호의 좌측 문자를 기준으로 찾습니다.

see('a+') # 'a' 글자가 한 개 이상 존재하는 경우

see('ac+') # 'a' 다음에 'c'가 하나 이상 있음

“*”

*(곱하기)는 앞 문자가 0개이상 인 경우를 의미합니다.

see('a*') # 'a' 글자를 반환

see('ac*')# 'a' 다음에 'c'가 없거나 하나 이상 있음

*** **(곱하기)는 +(더하기)와 유사하지만 결정적인 차이점으로 +(더하기)는 기호에 해당하는 문자가 하나라도 있는 문자를 반환하지만, *(곱하기)는 앞에 해당문자가 존재하지 않더라도 반환하는 특징이 있습니다.

“\[ \]”

\[ \](대괄호)는 문자를 묶어서 표현할때 사용됩니다. 대괄호에 묶인 문자들은 각각 or로 취급이 됩니다.

see('[abc]') # 'a' or 'b' or 'c'를 찾아 반환

see('[abcde]c') # 'c' 앞에 'a' or 'b' or 'c' or 'd' or 'e' 문자를 찾아 반환 ('ac', 'bc' 반환)

see('[A-Z][A-Z]C') # 'C'의 두 부분 앞 문자에서 A부터 Z글자까지 있는 문자를 찾아서 반환 ('ABC' 반환)

또한, 특정한 문자를 제외하는 의미로서 대괄호 안에 ^(윗 꺽쇠)를 사용합니다.

see('[^abc]') # 'a' or 'b' or 'c'를 제외한 문자를 반환

“{ }”

{ }(중괄호)는 문자의 개수를 샐때 사용됩니다. 중괄호에는 세가지 용법이 있습니다.

{n,m} : 앞 문자가 n개 이상 m개 이하를 의미.
{n,} : 앞 문자가 n개 이상을 의미.
{n} : 앞 문자가 정확하게 n개를 의미.

see('a{1,2}') # 'a' 글자가 1개 이상 2개 이하를 표시

see('b{1,}') # 'b' 글자가 1개 이상인 경우를 표시

see('c{1}') # 'c' 글자가 1개인 경우를 표시

“( )”

( )(소괄호)는 문자를 묶어서 표현할때 사용합니다. 소괄호에 묶인 문자들은 각각 and로 취급됩니다.

see('(abc)') # 'abc' 문자를 찾아 반화

see('(abcde)c') # 'c' 앞에 'abcde' 문자를 찾아 반환 (조건에 맞는 결과 없음)

see('a(bc)ba') # 'a' 와 'ba' 사이에 'bc'가 존재하는 경우의 문자를 반환 ('abcba' 반환)

see('a(b|c)ba') # 'a' 와 'ba' 사이에 'b' 또는 'c'가 존재하는 경우의 문자를 반환 ('abba' 반환 )

대괄호에 묶인 문자는 ‘or’ 취급이지만, 소괄호는 위의 경우처럼 별도의 or 표시 없이는 ‘and’ 취급이 되는것이 차이점입니다.

“\”

앞서 .(마침표)는 임의의 한 글자를 찾을때 사용하는 메타문자라고 말씀을 드렸는데요. 그렇다면 만약 정규표현식을 사용하여 마침표 자체를 찾고싶을땐 어떻게 해야할까요? ’a.a’라는 문자를 찾는 상황을 가정해보겠습니다.

see('a.a') # 'a.a' 문자 반환?

‘a.a’라는 문자를 찾은걸 볼 수 있지만, 그것과 더불어서 ’aaa,’ ‘aca,’ ’a a’문자 역시 매칭이 되는 것을 볼 수 있습니다. 그 이유는 공교롭게도 “.”(마침표)역시 정규표현식에서 특수한 의미를 갖는 메타문자이기 때문입니다. 정규표현식 내에서 메타문자 자체를 특정하기 위해선 그 문자 앞에 메타문자 종류중 하나인 “\”(역슬래시)를 붙여야합니다.

그렇다면 이번에는 역슬래시를 활용하여 ’a.a’라는 문자를 찾아보도록 하겠습니다. 문자 가운데에 마침표가 메타문자가 아니라는것을 인지시키기 위하여 마침표 앞에 역슬래시를 붙였습니다.

see('a\.a') # 역슬래시 사용

#> Error: "'a\."로 시작하는 문자열 중에서 '\.'는 인식할 수 없는 이스케이프입니다

역슬래시를 사용했음에도 불구하고 에러가 발생하였습니다. 여기서 한가지 더 짚고 넘어가야 할 부분은 메타문자를 찾기 위해선 역슬래시를 두 개를 붙여야 한다는 것입니다. 왜 그러하냐 하면 입력된 문자를 R parser가 처리하는 과정에서 역슬래시를 추정하는데 두 개의 역슬래시를 요구하기 때문입니다. 역슬래시를 하나만을 붙여서는 R에서 인지하지 못합니다. 역슬래시의 기능을 사용하기 위해선 역슬래시 두 개를 붙여줘야 합니다. 그래야 비로소 R이 두 개 붙인 역슬래시 앞의 역슬래시가 일반문자가 아님을 인지하고 해당 패턴을 찾아냅니다.

이처럼 역슬래시가 메타문자를 메타문자로부터 탈출시키기에 이스케이프 문자라 부르기도 합니다.

see('a\\.a') # 역슬래시 두 개 사용

이번에는 찾고자 하던 ’a.a’단어를 정확하게 찾아낸 것을 볼 수 있습니다.

“\ + 일반문자”

앞서 역슬래시( \ )가 일반문자로 탈출시키는 이스케이프 문자라 설명드렸는데요. 정규표현식에서는 이러한 이스케이프 문자의 특성을 살린 특별한 기능이 몇 가지 더 있습니다. 그건 바로 일반 이스케이프 문자와 일반문자와의 조합을 통해 새로운 기능을 수행하는 것입니다. 일반문자중 일부 문자들은 이러한 특성을 지니고 있으며, 이를 정리하자면 다음과 같습니다.

＼ + 일반문자	의미	예시
＼n	줄바꿈	see(“\\n”)
＼t	탭	see(“\\t”)
＼s	공백	see(“\\s”)
＼S	공백아님	see(“\\S”)
＼d	숫자	see(“\\d”)
＼D	숫자아님	see(“\\D”)
＼w	문자	see(“\\w”)
＼W	문자아님	see(“\\W”)
＼b	단어경계	see(“\\b”)

특수표현

이 밖에도 정규표현식에서는 “\[: :\]” 형태로 존재하는 특수한 표현식이 존재합니다.

［: :］	의미	예시
［:digit:］	숫자	see(“［:digit:］”)
［:alpha:］	문자	see(“［:alpha:］”)
［:lower:］	소문자	see(“［:lower:］”)
［:upper:］	대문자	see(“［:upper:］”)
［:alnum:］	문자+숫자	see(“［:alnum:］”)
［:punct:］	기호	see(“［:punct:］”)
［:graph:］	문자+숫자+기호	see(“［:graph:］”)
［:space:］	띄어쓰기	see(“［:space:］”)
［:blank:］	띄어쓰기+탭	see(“［:blank:］”)

Note

참고로 위의 표에서 사용된 일부 역슬래시와 대괄호는 출력상의 이유로 인해 일반적으로 사용하는 문자가 아닌 특수문자로 대체하였습니다. 예시함수를 사용 할 때 혹시나 에러가 발생한다면 역슬래시와 대괄호를 원래 키로 수정하여 사용하시기 바랍니다.

위치 탐색자

다음은 문자를 기준으로 바로 앞뒤 문자를 찾거나 그 반대인 상황을 찾을때 사용하는 표현식입니다.

see('a(?=c)') # 'a'가 'c' 바로 뒤에 있는 경우를 반환

see('a(?!c)') # 'a'가 'c' 바로 뒤따르지 않는 경우를 반환

see('(?<=b)a') # 'a'가 'b' 바로 앞에 있는 경우를 반환

see('(?<!b)a') # 'a'가 'b' 바로 앞에 있지 않는 경우를 반환

정리를 하다보니 분량이 꽤나 길어진 것 같습니다. 정규표현식은 비단 R에서 뿐만 아니라 다른 프로그래밍 언어에서도 적극 사용되는 용법이어서 한번 익혀두면 두고두고 써먹을 수 있는 장점이 있는데요. 여기에 소개하지 못한 다른 정규표현식도 많이 존재합니다. 더 자세히 공부를 하고자 하시는 분들을 위한 링크를 밑에 삽입하였으니 참고하시면 도움이 될 수 있겠습니다. R에서 텍스트데이터를 다루는 패키지 중 하나인 stringr 패키지와 정규표현식을 결합하여 사용하면 더욱 효과적으로 사용할 수 있는데요. 이는 다음장에서 다뤄보도록 하겠습니다.