• 粉丝日志首页

当R语言遇上Docker

R的极客理想系列文章,涵盖了R的思想,使用,工具,创新等的一系列要点,以我个人的学习和体验去诠释R的强大。

R语言作为统计学一门语言,一直在小众领域闪耀着光芒。直到大数据的爆发,R语言变成了一门炙手可热的数据分析的利器。随着越来越多的工程背景的人的加入,R语言的社区在迅速扩大成长。现在已不仅仅是统计领域,教育,银行,电商,互联网….都在使用R语言。

要成为有理想的极客,我们不能停留在语法上,要掌握牢固的数学,概率,统计知识,同时还要有创新精神,把R语言发挥到各个领域。让我们一起动起来吧,开始R的极客理想。

关于作者:

  • 张丹(Conan), 程序员R,Nodejs,Java
  • weibo:@Conan_Z
  • blog: http://blog.fens.me
  • email: bsspirit@gmail.com

转载请注明出处:
http://blog.fens.me/r-docker

r-docker

前言

R语言作为数据分析的工具,已经广泛被大家所接受并使用。但要把R语言项目工程化,部署到生产环境,提供在线用户使用却是难度很大的。主要原因就是R本身是单线程的,不支持并行处理。

当R遇到上了Docker会发生什么呢?本文将做详细的解释。

目录

  1. 当R遇到上了Docker
  2. 用Docker来管理R的程序

1. 当R遇到上了Docker

前言中提到,R运行时环境是单线程的,不支持并行处理,所以我们很难把R直接应用到生产环境中。当R遇到上了Docker,就出现了一个可以解决上面问题的方案。

通过Docker的容器化技术,把R的应用Docker化。每当用户发出请求,程序可以自动地在线启动一个Docker化的容器,来装载R的任务,部署,运行,计算,并返回结果。

r-docker2

从极端的情况考虑,如果要面对100万次并发的请求,我们需要启动100万个Docker的容器,每次容器单独执行自己的任务。但这种情况是要避免的,因为R本身来说,是做数据任务的,并不善于处理web是请求。如果可以把用户的大批量请求,转换成少量的数据计算的任务,那么这个设计就完美地解决了R由于并发而不能被工程化的问题。

r-docker3

比如,针对大量用户的重复性计算,把R的计算结果保存在缓存池中。

2. 用Docker来管理R的程序

设计方案定好,接下来就是就是动手实践了。

操作过程分成4步:

  • 1. 要有Docker的环境
  • 2. 找到第三方成熟的R语言的Docker镜像
  • 3. 把我们的R程序装进去
  • 4. 打包,运行,上传

1. Docker的环境。

安装Docker环境,就不在本文中介绍了,Docker环境的安装,请参考文章在Ubuntu中安装Docker

2. 找到第三方成熟的R语言的Docker镜像。

在docker hub中,搜索关键字 r, 共有535条结果。我们直接选用,排在第一位的r-base做为Docker容器的基础就行了。

docker-r

从仓库中,下载r-base镜像。


# 下载r-base镜像,大概300mb要下一会儿
~ sudo docker pull r-base
Using default tag: latest
latest: Pulling from library/r-base
9cd73496e13f: Pull complete 
f10af350cd29: Pull complete 
eea7b33eea97: Pull complete 
c91475e50472: Pull complete 
1e5e5f6785b4: Pull complete 
8c4091261ff6: Pull complete 
Digest: sha256:5f06e5a89cc64cbc513d02a8c650ea8bcbf0499795add57d18793069795c6f8d
Status: Downloaded newer image for r-base:latest

# 查看本地镜像列表
~ sudo docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
bsspirit/fensme     latest              8496b10e857a        2 hours ago         182.8 MB
ubuntu              latest              f8d79ba03c00        2 weeks ago         126.4 MB
r-base              latest              e2abe45e47d7        3 weeks ago         959.9 MB

3. 把我们的R程序装进去。

把R程序放进去之前,我们要先通过命令交互的方法,看看r-base容器中,是什么样子的。

运行r-base容器,会直接打开一个R的命令行窗口。


~ sudo docker run -ti --rm r-base

R version 3.3.1 (2016-06-21) -- "Bug in Your Hair"
Copyright (C) 2016 The R Foundation for Statistical Computing
Platform: x86_64-pc-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.

  Natural language support but running in an English locale

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语言程序,了解一下Docker环境的信息。


# R程序启动路径
> getwd()
[1] "/"

# 当前路径中的目录
> dir()
 [1] "bin"   "boot"  "dev"   "etc"   "home"  "lib"   "lib64" "media" "mnt"  
[10] "opt"   "proc"  "root"  "run"   "sbin"  "srv"   "sys"   "tmp"   "usr"  
[19] "var"  

# 用户身份
> system('whoami')
root

# 系统信息
> sessionInfo()
R version 3.3.1 (2016-06-21)
Platform: x86_64-pc-linux-gnu (64-bit)
Running under: Debian GNU/Linux stretch/sid

locale:
 [1] LC_CTYPE=en_US.UTF-8       LC_NUMERIC=C              
 [3] LC_TIME=en_US.UTF-8        LC_COLLATE=en_US.UTF-8    
 [5] LC_MONETARY=en_US.UTF-8    LC_MESSAGES=en_US.UTF-8   
 [7] LC_PAPER=en_US.UTF-8       LC_NAME=C                 
 [9] LC_ADDRESS=C               LC_TELEPHONE=C            
[11] LC_MEASUREMENT=en_US.UTF-8 LC_IDENTIFICATION=C       

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base    

# R语言版本
> R.Version()
$platform
[1] "x86_64-pc-linux-gnu"

$arch
[1] "x86_64"

$os
[1] "linux-gnu"

$system
[1] "x86_64, linux-gnu"

$status
[1] ""

$major
[1] "3"

$minor
[1] "3.1"

$year
[1] "2016"

$month
[1] "06"

$day
[1] "21"

$`svn rev`
[1] "70800"

$language
[1] "R"

$version.string
[1] "R version 3.3.1 (2016-06-21)"

$nickname
[1] "Bug in Your Hair"

通过上面的几条命令,r-base容器的系统环境已经掌握。接下来,我们可以写一个R的算法,让这个程序在r-base的容器中运行。退出容器。

新建项目目录


~ mkdir ret && cd ret
~ pwd
/home/conan/ret

我们用a.r写一个计算万科(WANK)000002.SZ股票收益率的程序。数据从yahoo财经进行采集,R语言用于收益率计算,计算结果通过在控制台打印。

wanke

新建R语言算法文件,a.r。


~ vi a.r

install.packages(c('quantmod','PerformanceAnalytics'))
library(quantmod)
library(PerformanceAnalytics)
VANKE<-getSymbols("000002.SZ",auto.assign = FALSE, from = '2010-10-10')
close<-VANKE$'000002.SZ.Close'
ret<-CalculateReturns(close, method = "discrete")
cumret<-cumprod((ret+1)[-1])-1
VANKE_ret<-merge(close,ret,cumret)
names(VANKE_ret)<-c('close','ret','cumret')
print(tail(VANKE_ret))

我们先在本机中运行这段代码。


> 安装类库
> install.packages(c('quantmod','PerformanceAnalytics'))
> # 装载类库
> library(quantmod)
> library(PerformanceAnalytics)
> 
> # 获得VANKE每K线数据
> VANKE<-getSymbols("000002.SZ",auto.assign = FALSE, from = '2010-10-10')
>
> # 收盘价
> close<-VANKE$'000002.SZ.Close'
> 
> # 每日收益率 = (T日收盘价 - (T-1日收盘价))/T-1日收盘价
> ret<-CalculateReturns(close, method = "discrete")
> 
> # 每日累计收盘率 = (T日收益率+1)*(T+1日收益率+1)*...*(T+N日收益率+1)-1
> cumret<-cumprod((ret+1)[-1])-1
> 
> # 合并数据集
> VANKE_ret<-merge(close,ret,cumret)
> names(VANKE_ret)<-c('close','ret','cumret')
> 
> # 查看VANKE最近几日收益率
> print(tail(VANKE_ret))
           close          ret   cumret
2016-08-18 25.58 -0.010444874 1.893665
2016-08-19 24.59 -0.038702111 1.781674
2016-08-22 24.70  0.004473363 1.794118
2016-08-23 24.70  0.000000000 1.794118
2016-08-24 23.99 -0.028744939 1.713801
2016-08-25 23.54 -0.018757816 1.662896

接下来,编写Dockerfile通过加载外部文件的方法。


~ vi Dockerfile

FROM r-base
COPY . /usr/local/src/myscripts
WORKDIR /usr/local/src/myscripts
CMD ["Rscript", "a.r"]

4. 打包,运行,上传。

打包,生成Docker的镜像文件a.r。


~ sudo docker build -t a.r .
[sudo] password for conan: 
Sending build context to Docker daemon 3.072 kB
Step 1 : FROM r-base
 ---> e2abe45e47d7
Step 2 : COPY . /usr/local/src/myscripts
 ---> e6ef215d3683
Removing intermediate container aaabfdfe92ab
Step 3 : WORKDIR /usr/local/src/myscripts
 ---> Running in e3f2c65b947a
 ---> c667baee06bf
Removing intermediate container e3f2c65b947a
Step 4 : CMD Rscript a.r
 ---> Running in dc040bbdd3b9
 ---> 9a48d6dc02fe
Removing intermediate container dc040bbdd3b9
Successfully built 9a48d6dc02fe

启动r-base容器,运行a.r的脚本。


~  sudo docker run a.r

看着大段的日志从眼前飞过,计算出了万科的收益率的结果。

docker-r2

最后一步,不忘上传到docker hub,仓库地址为:https://hub.docker.com/r/bsspirit/ret/

上传镜像的操作命令:


~ sudo docker tag 9a48d6dc02fe bsspirit/ret
~ sudo docker push bsspirit/ret

如果你有Docker的环境,你可以直接用下面的命令,进行容器下载和运行。


~ sudo docker run bsspirit/ret

R和Docker的相遇,给R提供了并行计算施展的空间。Docker和R的相遇,也让Docker能够切入数据处理领域,有了更广阔的应用场景。感谢R和Docker给程序员的世界,带来了新的机会!!

转载请注明出处:
http://blog.fens.me/r-docker

打赏作者

在Ubuntu中安装Docker

Ubuntu实用工具系列文章,将介绍基于Linux ubuntu的各种工具软件的配置和使用。有些工具大家早已耳熟能详,有些工具经常用到但确依然陌生。我将记录我在使用操作系统时,安装及配置工具上面的一些方法,把使用心得记录下来也便于自己的以后查找和回忆。

关于作者:

  • 张丹, 程序员R,Nodejs,Java
  • weibo:@Conan_Z
  • blog: http://blog.fens.me
  • email: bsspirit@gmail.com

转载请注明出处:
http://blog.fens.me/linux-docker-install/

ubuntu-docker

前言

网上已经有很多介绍Docker安装的文章,自己的安装过程记录一下,为了博客文章结构的连贯性,为写下一篇R和Docker的相遇做为环境基础,同时也给自己一个备忘。

目录

  1. Docker是什么?
  2. 在Linux Ubuntu中安装Docker
  3. Docker镜像仓库
  4. 制作自己的Docker镜像
  5. 上传Docker镜像到公共仓库

1. Docker是什么?

在互联网圈混,如果还不知道Docker你就out了。从2014年开始,docker技术在互联网技术中异军突起,2015-2016年很多公司已经对Docker开始大量研究和应用。

Docker是什么?Docker是一个开源的应用容器引擎,系统级的轻量虚拟化技术,为应用程序的自动化部署提供解决方案。

你可以快速创建一个容器,并在容器上开发和运行你们的应用程序,通过配置文件可以轻松实现应用程序的自动化安装、部署和升级。

Docker的优势

Docker倍受业界追捧,必然有它非常明显的优势和特点。

  • 轻量级资源:容器是在进程级别隔离,并使用宿主机的内核,而不需要虚拟化整个操作系统。不需要虚拟化和系统调用复杂的操作。因此节省了很大的额外开销。不需要额外的hypervisor(虚拟化技术)支持,不需要虚拟硬件,不需要额外完整的系统。
  • 可移植性:所需要的应用都在容器中,可以在任意一台docker主机上运行
  • 可预测性:宿主机和容器相互不关心对方都运行什么。只考虑所需的接口标准化。

再不动手把Docker用上,你就真的out了。

2. 在Linux Ubuntu中安装Docker

安装Docker只需3步,下载Docker, 安装Docker,检查Docker是否成功。

Docker目前支持主流的3种操作系统的Linux, Mac, Windows的环境,本文使用的Linux系统环境为:Linux Ubuntu 14.04.4 LTS 64bit。在Ubuntu中下载和安装Docker可以直接用apt-get搞定。

由于Docker在1.7.1以后的版本指定了自己的源,所以我们需要先在APT中配置Docker的源。

更新APT的源,安装https和ca证书的库,默认这2个库都已经装了。


~ sudo apt-get update
~ sudo apt-get install apt-transport-https ca-certificates

添加秘钥GPG到APT配置中。


~ sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D

增加Docker的源到/etc/apt/souces.list文件中,我的版本是14.04对应ubuntu-trusty。


~ sudo vi /etc/apt/sources.list

# 增加到最后一行
deb https://apt.dockerproject.org/repo ubuntu-trusty main

接下来,就可以用可以用apt-get直接安装Docker了。


~ sudo apt-get update
~ sudo apt-get install docker-engine

安装完成,默认会启动Docker。


# 检查docker服务
~ service docker status
docker start/running, process 10013

# 检查docker进行
~ ps -aux|grep docker
root     10013  0.0  1.0 424948 40584 ?        Ssl  22:29   0:00 /usr/bin/dockerd --raw-logs
root     10022  0.0  0.2 199680 10280 ?        Ssl  22:29   0:00 docker-containerd -l unix:///var/run/docker/libcontainerd/docker-containerd.sock --shimdocker-containerd-shim --metrics-interval=0 --start-timeout 2m --state-dir /var/run/docker/libcontainerd/containerd --runtime docker-runc

# 检查docker版本
~ sudo docker version
Client:
 Version:      1.12.1
 API version:  1.24
 Go version:   go1.6.3
 Git commit:   23cf638
 Built:        Thu Aug 18 05:22:43 2016
 OS/Arch:      linux/amd64

Server:
 Version:      1.12.1
 API version:  1.24
 Go version:   go1.6.3
 Git commit:   23cf638
 Built:        Thu Aug 18 05:22:43 2016
 OS/Arch:      linux/amd64

检查Docker是否成功,运行hello-world。如果出现下面的信息,表示Docker引擎安装成功。


~ sudo docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
c04b14da8d14: Pull complete 
Digest: sha256:0256e8a36e2070f7bf2d0b0763dbabdd67798512411de4cdcf9431a1feb60fd9
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker Hub account:
 https://hub.docker.com

For more examples and ideas, visit:
 https://docs.docker.com/engine/userguide/

注意:我们在执行上面的命令的时候,经常会遇到一个错误。Cannot connect to the Docker daemon. Is the docker daemon running on this host?

比如,直接输入 docker run hello-world 命令。


~ docker run hello-world
docker: Cannot connect to the Docker daemon. Is the docker daemon running on this host?.
See 'docker run --help'.

这是由于权限的问题,docker默认和root权限绑定,如果不加sudo时则没有权限。

3. Docker镜像仓库

对于上面我们执行的docker run hello-world命令,是什么意思呢?

把3个词分开来看,docker代表docker程序,run代表命令,hello-world代表镜像。就是用docker启动hello-world镜像。由于我们刚装好的docker,本地并没有镜像,那么run的命令会对docker远端的仓库中,找到名叫hello-world的镜像,然后下载到本地,再运行。

Docker官方的镜像仓库访问地址:https://hub.docker.com/

我们可以在Docker官方的仓库中,搜索你感兴趣的系统、语言、技术框架等,有很多的技术都已经被docker化了。我们就可以很方便地用别人已经做好的容器,站在前人的基础上继续工作。

docker-repo

从列表中点开一项后,会有对这个镜像的详细介绍。比如,Ubuntu的镜像。

docker-repo2

如果我们想要下载这个镜像,只需要按照他的提示,在命令行输入 docker pull ubuntu 这样就行了。


~ sudo docker pull ubuntu
Using default tag: latest
latest: Pulling from library/ubuntu
2f0243478e1f: Pull complete 
d8909ae88469: Pull complete 
820f09abed29: Pull complete 
01193a8f3d88: Pull complete 
Digest: sha256:8e2324f2288c26e1393b63e680ee7844202391414dbd48497e9a4fd997cd3cbf
Status: Downloaded newer image for ubuntu:latest

下载好后镜像,会保存在本地的仓库中。查看本地的镜像。


~ sudo docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
ubuntu              latest              f8d79ba03c00        2 weeks ago         126.4 MB
hello-world         latest              c54a2cc56cbb        7 weeks ago         1.848 kB

目前,有2个本地镜像,一个是hello-world,另一个是ubuntu。

4. 制作自己的Docker镜像

我们也可以制作自己的镜像,然后上传到官方的仓库中,让更多的人来使用。如果要制作自己的Docker镜像,你只需要写一个Dockerfile文件就行了。

下面我们创建一个能进行网络访问的Docker,从http://fens.me网站抓取最新8篇的文章列表,并打印到控制台。

docker-curl-fensme

创建项目目录


~ mkdir fensme && cd fensme

创建Dockerfile,依赖于上文中下载的ubuntu镜像,还要需要安装curl库用于网页抓取,同时用于jq库解析JSON数据。


~ vi Dockerfile

FROM ubuntu:latest
RUN apt-get update && apt-get install -y curl jq
CMD curl http://api.fens.me/blogs/ | jq .[]

打包,创建名为fensme的镜像。


# 打包
~ sudo docker build -t fensme .

# 查看镜像列表
~ sudo docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
fensme              latest              41b68972b35a        4 minutes ago       182.8 MB
ubuntu              latest              f8d79ba03c00        2 weeks ago         126.4 MB
hello-world         latest              c54a2cc56cbb        7 weeks ago         1.848 kB

运行fensme的镜像,这样就实现了网站数据的抓取。


~ sudo docker run fensme
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  1421  100  1421    0     0    715      0  0:00:01  0:00:01 --:--:--   715
{
  "title": "R语言解读自回归模型",
  "date": 20160819,
  "link": "http://blog.fens.me/r-ar/",
  "img": "http://blog.fens.me/wp-content/uploads/2016/08/r-ar.png"
}
{
  "title": "R语言量化投资常用包总结",
  "date": 20160810,
  "link": "http://blog.fens.me/r-quant-packages/",
  "img": "http://blog.fens.me/wp-content/uploads/2016/08/quant-packages.png"
}
{
  "title": "R语言跨界调用C++",
  "date": 20160801,
  "link": "http://blog.fens.me/r-cpp-rcpp",
  "img": "http://blog.fens.me/wp-content/uploads/2016/08/rcpp.png"
}
{
  "title": "R语言解读多元线性回归模型",
  "date": 20160727,
  "link": "http://blog.fens.me/r-multi-linear-regression/",
  "img": "http://blog.fens.me/wp-content/uploads/2016/07/reg-multi-liner.png"
}
{
  "title": "R语言解读一元线性回归模型",
  "date": 20160725,
  "link": "http://blog.fens.me/r-linear-regression/",
  "img": "http://blog.fens.me/wp-content/uploads/2016/07/reg-liner.png"
}
{
  "title": "R语言中文分词包jiebaR",
  "date": 20160721,
  "link": "http://blog.fens.me/r-word-jiebar/",
  "img": "http://blog.fens.me/wp-content/uploads/2016/07/jiebaR.png"
}
{
  "title": "2016天善智能交流会第22场: R语言为量化而生",
  "date": 20160704,
  "link": "http://blog.fens.me/meeting-hellobi-20160701/",
  "img": "http://blog.fens.me/wp-content/uploads/2016/07/meeting-hellobi.png"
}
{
  "title": "R语言为量化而生",
  "date": 20160703,
  "link": "http://blog.fens.me/r-finance/",
  "img": "http://blog.fens.me/wp-content/uploads/2016/07/r-finance.png"
}

这个例子,我们通过Docker封装了一个非常简单的爬虫,当你需要的时候启动它,把结果写到数据库中。当执行完任务,系统资源就释放了,你需要再为它考虑。

比较简单地就可以把一个技术或一个功能Docker化,从而构建出个性化的Docker。

5. 上传Docker镜像到公共仓库

最后一步,其实就是把我们做好的Docker镜像上传到官方的仓库中,让其他的人也可以使用。

首先需要去docker hub上面注册一个账号,然后登录进去。

docker-hub-login

在docker hub上,创建一个自己的仓库。

docker-hub-create

在本地操作系统,绑定docker hub的账号


~ sudo docker login --username=bsspirit --email=bsspirit@163.com
Flag --email has been deprecated, will be removed in 1.13.
Password: 
Login Succeeded

接下来,要你刚才创建的fensme的镜像加上命名空间,对应该docker hub上面镜像名bsspirit/fensme。


# 给fensme增加命名空间
~ sudo docker tag 8496b10e857a bsspirit/fensme:latest

~ sudo docker images
REPOSITORY          TAG                 IMAGE ID            CREATED              SIZE
bsspirit/fensme     latest              8496b10e857a        About a minute ago   182.8 MB
fensme              latest              8496b10e857a        15 minutes ago       182.8 MB
ubuntu              latest              f8d79ba03c00        2 weeks ago          126.4 MB
hello-world         latest              c54a2cc56cbb        7 weeks ago          1.848 kB

上传bsspirit/fensme镜像,然后你就可以在docker hub的网站上看到你自己的镜像了。


~ sudo docker push bsspirit/fensme
The push refers to a repository [docker.io/bsspirit/fensme]
d9c50c22842b: Pushed 
4699cbd1a947: Pushed 
2bed5b3ec49f: Pushed 
3834bde7e567: Pushed 
d8d865b23727: Pushed 
latest: digest: sha256:bfea736a92b6e602d6bbca867715b0e985f2e9bc3ea4a75b545d7e009e22ac2b size: 1362

打开docker hub网站,刷新页面。

docker-repo3

最后,如果其他人需要使用这个docker镜像,像最开始介绍的,直接下载运行就可以了。


~ sudo docker run bsspirit/fensme

通过上面的操作,我们就把Docker在Linux Ubuntu中的系统安装完成。

转载请注明出处:
http://blog.fens.me/linux-docker-install/

打赏作者

R语言解读自回归模型

R的极客理想系列文章,涵盖了R的思想,使用,工具,创新等的一系列要点,以我个人的学习和体验去诠释R的强大。

R语言作为统计学一门语言,一直在小众领域闪耀着光芒。直到大数据的爆发,R语言变成了一门炙手可热的数据分析的利器。随着越来越多的工程背景的人的加入,R语言的社区在迅速扩大成长。现在已不仅仅是统计领域,教育,银行,电商,互联网….都在使用R语言。

要成为有理想的极客,我们不能停留在语法上,要掌握牢固的数学,概率,统计知识,同时还要有创新精神,把R语言发挥到各个领域。让我们一起动起来吧,开始R的极客理想。

关于作者:

  • 张丹(Conan), 程序员R,Nodejs,Java
  • weibo:@Conan_Z
  • blog: http://blog.fens.me
  • email: bsspirit@gmail.com

转载请注明出处:
http://blog.fens.me/r-ar

r-ar

前言

时间序列是金融分析中常用到的一种数据格式,自回归模型是分析时间序列数据的一种基本的方法。通过建立自回归模型,找到数据自身周期性的规律,从而帮助我们理解金融市场的发展变化。

在时间序列分析中,有一个常用的模型包括AR,MA,ARMA,ARIMA,ARCH,GARCH,他们的主要区别是适用条件不同,且是层层递进的,后面的一个模型解决了前一个模型的某个固有问题。本文以AR模型做为开始,将对时间序列分析体系,进行完整的介绍,并用R语言进行模型实现。

由于本文为非统计的专业文章,所以当出现与教课书不符的描述,请以教课书为准。本文力求用简化的语言,来介绍自回归模型的知识,同时配合R语言的实现。

目录

  1. 自回归模型介绍
  2. 用R语言构建自回归模型
  3. 模型识别ACF/PACF
  4. 模型预测

1. 自回归模型(AR)

自回归模型(Autoregressive model),简称AR模型,是统计上一种处理时间序列的方法,用来描述当前值与历史值之间的关系,用变量自身的历史时间数据对自身进行预测,自回归模型必须满足平稳性的要求。比如,时间序列数据集X 的历史各期数据从X1至Xt-1,假设它们为线性关系,可以对当期Xt的表现进行预测。X的当期值等于一个或数个落后期的线性组合,加常数项,加随机误差。

p阶自回归过程的公式定义:

ar-forumla

字段解释:

  • Xt是当期的X的表现
  • c是常数项
  • p是阶数,i为从1到p的值
  • φi是自相关系数
  • t为时间周期
  • εt是均值为0,标准差为δ 的随机误差,同时δ是独立于t的

对于一阶自回模型,用AR(1)来表示,简化后的公式为:

ar1-forumla

自回归是从线性回归分析中发展而来,只是把自变量x对因变量y的分析,变成自变量x对自身的分析。如果你需要了解线性回归的知识,请参考文章R语言解读一元线性回归模型

自回归模型的限制

自回归模型是用自身的数据来进行预测,但是这种方法受到一定的限制:

  • 必须具有平稳性,平稳性要求随机过程的随机特征不随时间变化。
  • 必须具有自相关性,如果自相关系数(φi)小于0.5,则不宜采用,否则预测结果极不准确。
  • 自回归只适用于预测与自身前期相关的现象,即受自身历史因素影响较大的现象。对于受其他因素影响的现象,不宜采用自回归,可以改用向量自回归模型。

平稳性时间序列的特点

平稳性要求产生时间序列Y的随机过程的随机特征不随时间变化,则称过程是平稳的;假如该随机过程的随机特征随时间变化,则称过程是非平稳的。

平稳性是由样本时间序列所得到的拟合曲线,在未来的一段期间内能顺着现有的形态能一直地延续下去;如果数据非平稳,则说明样本拟合曲线的形态不具有延续的特点,也就是说拟合出来的曲线将不符合当前曲线的形态。

  • 随机变量Yt的均值和方差均与时间t无关
  • 随机变量Yt和Ys的协方差只与时间差(步长)t-s有关
  • 对于平稳时间序列在数学上有比较丰富的处理手段,非平稳的时间序列通过差分等手段转化为平稳时间序列处理

2. 用R语言构建自回归模型

了解了自回归模型的定义,我们就可以用R语言来模拟一下自回归模型的构建和计算过程。

生成一个随机游走的数据集,满足平稳性的要求。


# 随机游走的数据集
> set.seed(0)
> x<-w<-rnorm(1000)       # 生成符合正态分布N(0,1)的数据
> for(t in 2:1000) x[t]<-x[t-1]+w[t]
> tsx<-ts(x)              # 生成ts时间序列的数据集

# 查看数据集
> head(tsx,15)
 [1] 1.2629543 0.9367209 2.2665202 3.5389495 3.9535909 2.4136409
 [7] 1.4850739 1.1903534 1.1845862 3.5892396 4.3528331 3.5538238
[13] 2.4061668 2.1167053 1.8174901

> plot(tsx)            # 生成可视化图形 
> a<-ar(tsx);a         # 进行自回归建模

Call:
ar(x = tsx)

Coefficients:
     1  
0.9879  

Order selected 1  sigma^2 estimated as  1.168

数据的如图展示:
01

自相关系数为0.9879 ,这是一个非常强的自相关性,所以上述的数列符合自相关的特性。

R语言中ar()函数提供了多种自相关系数的估计,包括"yule-walker", "burg", "ols", "mle", "yw",默认是用yule-walker方法,常用的方法还有最小二乘法(ols),极大似然法(mle)。

我们用最小二乘法,来进行参数估计。


> b<-ar(tsx,method = "ols");b

Call:
ar(x = tsx, method = "ols")

Coefficients:
     1  
0.9911  

Intercept: -0.017 (0.03149) 

Order selected 1  sigma^2 estimated as  0.9906

用最小二乘法的计算结果,则自相关系统数为0.9911,截距为-0.017。只有使用最小二乘法进行参数估计的时候,才会有截距。

我们用极大似然法,来进行参数估计。


> d<-ar(tsx,method = "mle");d

Call:
ar(x = tsx, method = "mle")

Coefficients:
     1  
0.9904  

Order selected 1  sigma^2 estimated as  0.9902

用极大似然法计算结果,则自相关系统数为0.9904。对于上面3种估计方法,自相关系数的值都是很接近的。

3. 模型识别ACF/PACF

在上面的例子中,我们默认是用一阶的自回归模型AR(1),进行程序实现的。在实际应用中,自回归模型AR时间序列的阶数P是未知的,必须根据实际数据来决定,就要对AR模型定阶数。常的方法就是利用自相关函数(ACF)和偏自相关函数(PACF)来确定自回归模型的阶数。在ACF/PACF不能确定的情况下,还需要用AIC(Aikaike info Criterion)、BIC(Bayesian information criterion)的信息准则函数来确定阶数。

自回归模型的确立过程,是通过确定阶数,参数估计,再次确定阶数的方法进行判断。自相关函数ACF,用来确定采用自回归模型是否合适。如果自相关函数具有拖尾性,则AR模型为合适模型。偏自相关函数PACF用来确定模型的阶数,如果从某个阶数之后,偏自相关函数的值都很接近0,则取相应的阶数作为模型阶数,偏自相关函数通过截尾性确定阶数。

1. 自相关函数ACF(autocorrelation function)

将一个有序的随机变量序列与其自身相比较,这就是自相关函数在统计学中的定义。每个不存在相位差的序列,都与其自身相似,即在此情况下,自相关函数值最大。如果序列中的组成部分相互之间存在相关性(不再是随机的),则由以下相关值方程所计算的值不再为零,这样的组成部分为自相关。

自相关函数反映了同一序列在不同时序的取值之间的相关程序。

ACF的公式为:

acf-forumla

字段解释

  • Pk,为ACF的标准误差
  • t,为数据集的长度
  • k,为滞后,取值从1到t-1,表示相距 k个时间间隔的序列值之间的相关性
  • Yt,为样本在t时期的值
  • Yt-k,为样本在t-k时期的值
  • μ,为样本的均值

所得的自相关值Pk的取值范围为[-1,1],1为最大正相关值,-1则为最大负相关值,0为不相关。

根据上面公式,我们可以手动计算出tsx数据集的ACF值


> u<-mean(tsx)  #均值
> v<-var(tsx)   #方差

> # 1阶滞后
> p1<-sum((x[1:length(tsx)-1]-u)*(x[2:length(tsx)]-u))/((length(tsx)-1)*v);p1
[1] 0.9878619
> # 2阶滞后
> p2<-sum((x[1:(length(tsx)-2)]-u)*(x[3:length(tsx)]-u))/((length(tsx)-1)*v);p2
[1] 0.9760271
> # 3阶滞后
> p3<-sum((x[1:(length(tsx)-3)]-u)*(x[4:length(tsx)]-u))/((length(tsx)-1)*v);p3
[1] 0.9635961

同时,我们可以用R语言中的acf()函数来计算,会打印前30个滞后的ACF值。


> acf(tsx)$acf
, , 1

           [,1]
 [1,] 1.0000000
 [2,] 0.9878619
 [3,] 0.9760271
 [4,] 0.9635961
 [5,] 0.9503371
 [6,] 0.9384022
 [7,] 0.9263075
 [8,] 0.9142540
 [9,] 0.9024862
[10,] 0.8914740
[11,] 0.8809663
[12,] 0.8711005
[13,] 0.8628609
[14,] 0.8544984
[15,] 0.8462270
[16,] 0.8384758
[17,] 0.8301834
[18,] 0.8229206
[19,] 0.8161523
[20,] 0.8081941
[21,] 0.8009467
[22,] 0.7942255
[23,] 0.7886249
[24,] 0.7838154
[25,] 0.7789733
[26,] 0.7749697
[27,] 0.7709313
[28,] 0.7662547
[29,] 0.7623381
[30,] 0.7604101
[31,] 0.7577333

比较前3个值的计算结果,与我们自己的计算结果是一样的,同时可以用R语言进行可视化输出。


> acf(tsx)

02

从上图中看出,数据的ACF为拖尾,存在很严重的自相关性。接下来,这时候我们用偏自相关函数确定一下AR的阶数。

2. 偏自相关函数(PACF)(partial autocorrelation function)

偏自相关函数是有自相关函数推到而来。对于一个平稳AR(p)模型,求出滞后k自相关系数p(k)时,实际上得到并不是x(t)与x(t-k)之间单纯的相关关系。因为x(t)同时还会受到中间k-1个随机变量x(t-1)、x(t-2)、……、x(t-k+1)的影响,而这k-1个随机变量又都和x(t-k)具有相关关系,所以自相关系数p(k)里实际掺杂了其他变量对x(t)与x(t-k)的影响。

为了能单纯测度x(t-k)对x(t)的影响,引进偏自相关系数的概念。对于平稳时间序列{x(t)},所谓滞后k偏自相关系数指在给定中间k-1个随机变量x(t-1)、x(t-2)、……、x(t-k+1)的条件下,或者说,在剔除了中间k-1个随机变量x(t-1)、x(t-2)、……、x(t-k+1)的干扰之后,x(t-k)对x(t)影响的相关程度。

简单来说,就是自相关系数ACF还包含了其他变量的影响,而偏自相关系数PACF是严格这两个变量之间的相关性。在ACF中存在着线性关系和非线性关系,偏自相关函数就是把线性关系从自动关系性中消除。当PACF近似于0,表明两个时间点之间的关系性是完全由线性关系所造成的。

通过R语言的pacf()函数来进行偏自相关函数计算。


> pacf(tsx)$acf
, , 1

              [,1]
 [1,]  0.987861891
 [2,]  0.006463542
 [3,] -0.030541593
 [4,] -0.041290415
 [5,]  0.047921168
 [6,] -0.009774246
 [7,] -0.006267004
 [8,]  0.002146693
 [9,]  0.028782423
[10,]  0.014785187
[11,]  0.019307564
[12,]  0.060879259
[13,] -0.007254278
[14,] -0.004139848
[15,]  0.015707900
[16,] -0.018615370
[17,]  0.037067452
[18,]  0.019322565
[19,] -0.048471479
[20,]  0.023388065
[21,]  0.027640953
[22,]  0.051177900
[23,]  0.028063875
[24,] -0.003957142
[25,]  0.034030631
[26,]  0.004270416
[27,] -0.029613088
[28,]  0.033715973
[29,]  0.092337583
[30,] -0.031264028

# 可视化输出 
> pacf(tsx)

03

从上面的这个结果分析,当滞后为1时AR模型显著,滞后为其他值是PACF的值接近于0不显著。所以,对于数据集tsx来说,数据满足AR(1)的自回归模型。对于上文中参数估计出的1阶自相关系数值是可以用的。

4. 模型预测

通过模型识别,我们已经确定了数据集tsx是符合AR(1)的建模条件的,同时我们也创建了AR(1)模型。接下来,就可以利用这个自回测的模型的进行预测,通过规律发现价值。在R语言中,我们可以用predict()函数,实现预测的计算。

使用AR(1)模型进行预测,并保留前5个预测点。


> predict(a,10,n.ahead=5L)
$pred
Time Series:
Start = 2 
End = 6 
Frequency = 1 
[1] 9.839680 9.681307 9.524855 9.370303 9.217627

$se
Time Series:
Start = 2 
End = 6 
Frequency = 1 
[1] 1.080826 1.519271 1.849506 2.122810 2.359189

上面结果中,变量$pred表示预测值,变量$se为误差。

我可以生成可视化的图,更直观的看到预测的结果。


# 生成50个预测值 
> tsp<-predict(a,n.ahead=50L)

# 把原数据画图 
> plot(tsx)

# 把预测值和误差画出来
> lines(tsp$pred,col='red')                
> lines(tsp$pred+tsp$se,col='blue')
> lines(tsp$pred-tsp$se,col='blue')

04

图中,黑色线为原始数据的,红色线为预测值,蓝色线为预测值的范围。这样我们就利用AR(1)模型,实现了对规律的预测计算。

上面关于预测和可视化的过程,我们是通过原生的predict()函数和plot()函数完成的。在R语言中,可以用forecast包来简化上面的操作过程,让代码更少,操作更便捷。


# 加载forecast包
> library('forecast')

# 生成模型AR(1) 
> a2 <- arima(tsx, order=c(1,0,0))
> tsp2<-forecast(a2, h=50)
> plot(tsp2)

05

查看forecast()计算后的预测结果。


> tsp2
     Point Forecast     Lo 80      Hi 80     Lo 95       Hi 95
1001      -15.71590 -16.99118 -14.440628 -17.66627 -13.7655369
1002      -15.60332 -17.39825 -13.808389 -18.34843 -12.8582092
1003      -15.49181 -17.67972 -13.303904 -18.83792 -12.1456966
1004      -15.38136 -17.89579 -12.866932 -19.22685 -11.5358726
1005      -15.27197 -18.06994 -12.474000 -19.55110 -10.9928432
1006      -15.16362 -18.21425 -12.112996 -19.82915 -10.4980922
1007      -15.05631 -18.33593 -11.776682 -20.07206 -10.0405541
1008      -14.95001 -18.43972 -11.460312 -20.28705  -9.6129750
1009      -14.84474 -18.52891 -11.160567 -20.47919  -9.2102846
1010      -14.74046 -18.60591 -10.875013 -20.65216  -8.8287673
1011      -14.63718 -18.67257 -10.601802 -20.80877  -8.4655994
1012      -14.53489 -18.73030 -10.339486 -20.95121  -8.1185723
1013      -14.43357 -18.78024 -10.086905 -21.08123  -7.7859174
1014      -14.33322 -18.82333  -9.843112 -21.20026  -7.4661903
1015      -14.23383 -18.86034  -9.607319 -21.30947  -7.1581923
1016      -14.13538 -18.89190  -9.378864 -21.40985  -6.8609139

通过forecast()函数,直接生成了Forecast值,80%概率的预测值范围,和95%概率的预测值范围。

在明白了整个自回归模型的设计思路、建模过程、检验条件、预测计算、可视化展示的完整操作后,我们就可以真正地把自回归模型用到实际的业务中。发现规律,发现价值!!

自回归模型只是开始,下一篇继续介绍移动平均模型(MA)的建模和使用过程。

转载请注明出处:
http://blog.fens.me/r-ar

打赏作者

R语言量化投资常用包总结

用IT技术玩金融系列文章,将介绍如何使用IT技术,处理金融大数据。在互联网混迹多年,已经熟练掌握一些IT技术。单纯地在互联网做开发,总觉得使劲的方式不对。要想靠技术养活自己,就要把技术变现。通过“跨界”可以寻找新的机会,创造技术的壁垒。

金融是离钱最近的市场,也是变现的好渠道!今天就开始踏上“用IT技术玩金融”之旅!

关于作者:

  • 张丹(Conan), 程序员Java,R,Nodejs
  • weibo:@Conan_Z
  • blog: http://blog.fens.me
  • email: bsspirit@gmail.com

转载请注明出处:
http://blog.fens.me/r-quant-packages/

quant-packages

前言

总是被很多的人问,为什么用R语言做量化投资,R、Python、Matlab比起来哪个更好?其实,答案很简单,你哪个用的熟就用哪个,工具是用来提升效率的,结果才是你会得到的。认准一门语言,坚持把它做好你就会成长。

每个领域,每种编程语言都用推动它前进的人,跟上牛人的脚步,你慢慢地也会变牛。

目录

  1. 为什么用R语言做量化投资?
  2. 常用量化投资工具包

1. 为什么用R语言做量化投资?

R做量化投资到底有哪些优势呢?最主要的一点,就是R语言有很多第三方包的支持。通常编程语言的设计,都是为了解决软件开发和程序实现的问题。但R语言在开始时,就被设计为主要解决数据的问题。量化投资就是对数据进行各种数据处理、数据分析,从而找到数据的规律。所以,有很多从事量化投资的人,把R语言用来构建量化交易的模型,进行回测,风险管理等,最后把研究成果开源并贡献给R语言的社区,为后面的人提供了非常大的帮助。

相比Python来说也有很多的第三方包的支持,这些第三方大部分提供是Web开发,数据爬虫,系统管理,数据库调用,数学计算等,这些都是属于通用的软件需求,而非某个行业的数据需求。当某个Python大神,开始关注量化投资领域,并用Python实现了一套量化的程序库,后面的人就会进入这个领域,只是沿着大神的路线走,等待下一个大神的出现。所以本质上,Python是面向程序设计的语言,而R是面向数据的语言。

R语言在量化投资领域,已经有很多年的积累,很多的算法已经成型。从投资研究到交易分析,再到风险管理,有着完整的体系结构。我们同样可以沿着前人走出来的路,快速学习,快速搭建出量化投资的系统来。对于有IT但背景缺乏金融知识的人来说,有很多的部分知识上手比较困难,同时看不太懂各种统计指标,对学习造成了很大的阻力。这其实是你深入到具体地某个行业后,都会面临的问题。行业知识和数学知识才是最难的,只有突破了,你才能打开认知新领域的方法。

R语言让我们更接近数据,同时提供了各种数学统计的工具,又有大量由第三方贡献的行业知识库,所以我会选择R语言,我会把R语言作为最好的工具,进行量化投资的分析。

2. 常用量化投资工具包

R语言在金融领域提供了很多的金融计算框架和工具,当你具备金融理论知识和市场经验,你可以利用这些第三方提供的技术框架来构建自己的金融模型。我们可以从CRAN上找到各种的金融项目,访问R的官方网站 (https://cran.r-project.org/),找到Task Views 菜单里的 Finance标签。

task

金融领域涉及范围是非常广的,包括银行业、保险业、信托业、证券业、租赁业等。金融行业都具有指标性、垄断性、高风险性、效益依赖性和高负债经营性的特点。量化投资是证券投资的一个很细分的专业领域,涉及到的金融工具包其实并不是太多。我们其实能把这些工具包研究好了,就可以方便地做量化的模型和交易了。

如果我们想用R构建自己的量化交易系统,你需要用到5方面的R语言工具包:数据管理、指标计算、回测交易、投资组合、风险管理。

quant-lib

  • 数据管理:包括数据集抓取、存储、读取、时间序列、数据处理等,涉及R包有 zoo(时间序列对象), xts(时间序列处理), timeSeries(Rmetrics系时间序列对象) timeDate(Rmetrics系时间序列处理), data.table(数据处理), quantmod(数据下载和图形可视化), RQuantLib(QuantLib数据接口), WindR(Wind数据接口), RJDBC(数据库访问接口), rhadoop(Hadoop访问接口), rhive(Hive访问接口), rredis(Redis访问接口), rmongodb(MongoDB访问接口), SparkR(Spark访问接口),fImport(Rmetrics系数据访问接口)等。
  • 指标计算:包括金融市场的技术指标的各种计算方法,涉及R包有 TTR(技术指标), TSA(时间序列计算), urca(单位根检验), fArma(Rmetrics系ARMA计算), fAsianOptions(Rmetrics系亚洲期权定价), fBasics(Rmetrics系计算工具), fCopulae(Rmetrics系财务分析), fExoticOptions(Rmetrics系期权计算), fGarch(Rmetrics系Garch模型), fNonlinear(Rmetrics系非线模型), fOptions(Rmetrics系期权定价), fRegression(Rmetrics系回归分析), fUnitRoots(Rmetrics系单位根检验) 等。
  • 回测交易:包括金融数据建模,并验证用历史数据验证模型的可靠性,涉及R包有 FinancialInstrument(金融产品), quantstrat(策略模型和回测), blotter(账户管理), fTrading(Rmetrics系交易分析)等。
  • 投资组合:对多策略或多模型进行管理和优化,涉及R包有 PortfolioAnalytics(组合分析和优化), stockPortfolio(股票组合管理), fAssets(Rmetrics系组合管理)等
  • 风险管理:对持仓进行风险指标的计算和风险提示,涉及R包有 PerformanceAnalytics(风险分析),fPortfolio(Rmetrics系组合优化), fExtremes(Rmetrics系数据处理)等。

基于上文中列出的R包,我们可以选择使用独立地第三方R包来构建我们的量化交易的系统,也可以选用完整的Rmetrics体系来构建量化交易的系统。这两类R包也可以混合使用,如果在混用时,由于他们基于的时间序列的底层对象是不一样的,那么类型转换的时候,可以你需要花点功夫处理一下。

上文中列出的R语言,并不是所有的R语言量化投资的R包,仅仅我关注的一些包。还有很多其他的,比如用于配对交易的包PairTrading;在Github上发布的,我并没有发现的R包等。

对于我自己来说,倾向于用独立地第三方R包来做量化交易系统,会用到其中的几个独立的R包。这样选择的主要原因有2个,一是中国市场比较特别,很多规则并不完全符合世界的标准。比如,股票T+1交易就是全球唯一的。另外一点是第三方的开源包,有一些可能有错误,所以你不应该把程序完全依赖于第三方包,要有独立的思考和判断,第三方包只是给我们提供了便利性。

那么常用的第三方R包的组合为:zoo, xts, TTR, quantmod, FinancialInstrument, quantstrat, blotter, PortfolioAnalytics, PerformanceAnalytics。这其中的任何一个包,都可以被替换或自己实现,从而保证自己量化交易系统的独特性。引用国外量化的教材上的一张图,国外用R来研究量化交易已经体系。

quantitative-analysis

图片摘自Introduction to Trading Systems,作者Guy Yollin。

本系列文章,稍后将对整个量化体系的金融R包进行全面的介绍,并加上我自己的理解。量化相关R包介绍的相关文章列表,持续更新中。。。

数据管理

策略模型

量化交易一条程序员可以利用技术优势,突破自己过上幸福生活的一条路,很艰难也很兴奋。我会一直坚持,希望路上的朋友一起加油!

转载请注明出处:
http://blog.fens.me/r-quant-packages/

打赏作者

R语言跨界调用C++

R的极客理想系列文章,涵盖了R的思想,使用,工具,创新等的一系列要点,以我个人的学习和体验去诠释R的强大。

R语言作为统计学一门语言,一直在小众领域闪耀着光芒。直到大数据的爆发,R语言变成了一门炙手可热的数据分析的利器。随着越来越多的工程背景的人的加入,R语言的社区在迅速扩大成长。现在已不仅仅是统计领域,教育,银行,电商,互联网….都在使用R语言。

要成为有理想的极客,我们不能停留在语法上,要掌握牢固的数学,概率,统计知识,同时还要有创新精神,把R语言发挥到各个领域。让我们一起动起来吧,开始R的极客理想。

关于作者:

  • 张丹(Conan), 程序员R,Nodejs,Java
  • weibo:@Conan_Z
  • blog: http://blog.fens.me
  • email: bsspirit@gmail.com

转载请注明出处:
http://blog.fens.me/r-cpp-rcpp

rcpp

前言

使用R语言已经很多年了,对很多的R包都已经了解,唯独没有碰和C++相关的部分,这可能很大的原因和我长期使用Java的背景有关。但随着多语言的发展,跨语言应用的流行,打通各语言界限的方法也已经是成熟。让R和C++实现通信,已经变得很简单。

跟上跨语言的步伐,打开R和C++的通道,让C++来解决R性能的诟病吧。

目录

  1. Rcpp的简单介绍
  2. 5分钟上手
  3. 数据类型转换

1. Rcpp的简单介绍

Rcpp包是一个打通R语言和C++语言的通信组件包,提供了R语言和C++函数的相互调用。R语言和C++语言的数据类型通过Rcpp包进行完整的映射。

Rcpp的官方网站:https://cran.r-project.org/web/packages/Rcpp/index.html

本文做为入门教程,只是简单介绍,如何能打通R语言和C++的通信通道,并不做深入地探讨。R语言和其他语言也有类似的通信实现,R语言和JAVA的调用,请参考文章解惑rJava R与Java的高速通道;R语言和Nodejs的调用,请参考文章Nodejs与R跨平台通信

2. 5分钟上手

做为5分钟上手的教程,我们只讲例子不讲API。

本文的系统环境

  • Win10 64bit
  • R version 3.2.3 (2015-12-10)

由于Windows系统的环境下需要Rtools支持,所以要手动下载对应版本的Rtoosl包,下载地址。我的R语言版本是3.2.3,所以我需要安装Rtools33.exe。安装EXE程序就不多说了,双击完成即可。

rtools

下载Rcpp的程序包,进行安装,一行代码搞定。


> install.packages("Rcpp")
trying URL 'https://mirrors.tuna.tsinghua.edu.cn/CRAN/bin/windows/contrib/3.2/Rcpp_0.12.6.zip'
Content type 'application/zip' length 3221864 bytes (3.1 MB)
downloaded 3.1 MB

package ‘Rcpp’ successfully unpacked and MD5 sums checked
Warning in install.packages :
  cannot remove prior installation of package ‘Rcpp’

The downloaded binary packages are in
	C:\Users\tinkpad\AppData\Local\Temp\RtmpKkg8zo\downloaded_packages

2.1 从hello world开始

从一个简单程序hello world开始吧,让R语言程序调用C++中的hello()函数。我用需要新建2个文件,放在同一个目录中。

  • demo.cpp,C++程序的源文件
  • demo.r,R程序源文件

首先,编辑demo.cpp,定义hello()函数。


~ notepad demo.cpp

#include <Rcpp.h>
#include <string>  

using namespace std;
using namespace Rcpp;

//[[Rcpp::export]]
string hello(string name) {
  cout << "hello " << name << endl;  
  return name;
}

/*** R
hello('world')
hello('Conan')
*/

上面Rcpp的代码,我们可以从3部分来看。

  • #include和using部分: 为包引用和命名空间的声明。<Rcpp.h>和namespace Rcpp是必要要加载的,另外由于使用了string的类型作为参数和返回值,所以需要<string>和namespace std。
  • 功能函数部分: 们定义了一个 hello(string name) 函数,有一个参数是string类型,返回值也为string类型。需要强调的是,对R开放的函数必须增加 //[[Rcpp::export]] 的注释声明
  • 代码执行: 用/*** R 和 */ 包含的部分,为R语言的代码,会默认被执行。

编辑demo.r,用来调用demo.cpp的hello()函数。


~ notepad demo.r

library(Rcpp)

sourceCpp(file='demo.cpp')
hello('R')

执行R语言的代码


# 加载Rcpp包
> library(Rcpp)

# 编译和加载demo.cpp文件
> sourceCpp(file='demo.cpp')

# 执行封装在demo.cpp中的R代码
> hello('world')
hello world
[1] "world"

> hello('Conan')
hello Conan
[1] "Conan"

# 执行hello函数
> hello('R')
hello [1]R
 "R"

一个非常简单的helloworld程序,就这样子完成了。

2.2 R和Rcpp的混写代码

上面2行代码,就完成了R对C++程序的调用,sourceCpp()函数真是强大。其实,sourceCpp()函数还提供了一种代码混写的方法,就是在R的代码中,直接嵌入C++代码。


sourceCpp(code='
  #include >Rcpp.h<
  #include >string<
  
  using namespace std;
  using namespace Rcpp;
  
  //[[Rcpp::export]]
  string hello(string name) {
    cout << "hello " << name << endl;  
    return name;
  }
')
hello('R2')

运行代码


> sourceCpp(code='
+   #include >Rcpp.h<
+   #include >string<
+   
+   using namespace std;
+   using namespace Rcpp;
+   
+   //[[Rcpp::export]]
+   string hello(string name) {
+     cout << "hello " << name << endl;  
+     return name;
+   }
+ ')

> hello('R2')
hello R2
[1] "R2"

这种多语言混写的语法虽然不太推荐,但对于这只有几行代码来说,还是很方便的。

2.2 用RStudioIDE生成cpp文件

如果你使用的RStudio IDE,开发起来将会非常方便,可以直接新建C++程序,生成一段标准的代码模板。

rstudio-cpp

生成的代码模板如下


#include <Rcpp.h>
using namespace Rcpp;

// This is a simple example of exporting a C++ function to R. You can
// source this function into an R session using the Rcpp::sourceCpp 
// function (or via the Source button on the editor toolbar). Learn
// more about Rcpp at:
//
//   http://www.rcpp.org/
//   http://adv-r.had.co.nz/Rcpp.html
//   http://gallery.rcpp.org/
//

// [[Rcpp::export]]
NumericVector timesTwo(NumericVector x) {
  return x * 2;
}

// You can include R code blocks in C++ files processed with sourceCpp
// (useful for testing and development). The R code will be automatically 
// run after the compilation.
//

/*** R
timesTwo(42)
*/

通过RStudio可以快速生成一段标准的代码模板,改改马上就能用了。

3. 数据类型转换

上面的例子中,我们测试了字符串类型的调用。R语言有多种的数据类型,我接下来都测试一下!

3.1 基本类型

基本类型,C++对应R语言的默认映射关系。C++的代码部分,如下所示:


// [[Rcpp::export]]
char char_type(char x){
  return x;
}

// [[Rcpp::export]]
int int_type(int x){
  return x;
}

// [[Rcpp::export]]
double double_type(double x){
  return x;
}

// [[Rcpp::export]]
bool bool_type(bool x){
  return x;
}

// [[Rcpp::export]]
void void_return_type(){
  Rprintf( "return void" );
}

执行R语言调用


# char类型
> a1<-char_type('a')
> a1;class(a1)         # 默认对应R的character类型
[1] "a"
[1] "character"
> char_type('bbii')    # 只处理字符串的第一个字节
[1] "b"

# int类型 
> a2<-int_type(111)
> a2;class(a2)         # 默认对应R的integer类型
[1] 111
[1] "integer" 
> int_type(111.1)      # 直接去掉小数位
[1] 111

# double类型 
> a3<-double_type(111.1)
> a3;class(a3)         # 默认对应R的numeric类型
[1] 111.1
[1] "numeric"
> double_type(111)
[1] 111

# boolean类型 
> a4<-bool_type(TRUE)
> a4;class(a4)        # 默认对应R的logical类型
[1] TRUE
[1] "logical"
> bool_type(0)        # 0为FALSE
[1] FALSE
> bool_type(1)        # 非0为TRUE
[1] TRUE

# 无参数无返回值 的函数
> a5<-void_return_type()
return void
> a5;class(a5)         # 返回值为NULL
NULL
[1] "NULL"

3.2 向量类型

向量类型,C++对应R语言的默认映射关系。C++的代码部分,如下所示:


// [[Rcpp::export]]
CharacterVector CharacterVector_type(CharacterVector x){
  return x;
}

// [[Rcpp::export]]
StringVector StringVector_type(StringVector x){
  return x;
}

// [[Rcpp::export]]
NumericVector NumericVector_type(NumericVector x) {
  return x;
}

// [[Rcpp::export]]
IntegerVector IntegerVector_type(IntegerVector x) {
  return x;
}

// [[Rcpp::export]]
DoubleVector DoubleVector_type(DoubleVector x){
  return x;
}

// [[Rcpp::export]]
LogicalVector LogicalVector_type(LogicalVector x){
  return x;
}

// [[Rcpp::export]]
DateVector DateVector_type(DateVector x){
  return x;
}

// [[Rcpp::export]]
DatetimeVector DatetimeVector_type(DatetimeVector x){
  return x;
}

执行R语言调用


# Character向量
> a6<-CharacterVector_type(c('abc','12345'))     
> a6;class(a6)                                    # 默认对应R的character类型
[1] "abc"   "12345"
[1] "character" 
> CharacterVector_type(c('abc',123.5, NA, TRUE))  # NA不处理
[1] "abc"   "123.5" NA      "TRUE" 

# String向量,完全同Character向量
> a7<-StringVector_type(c('abc','12345'))
> a7;class(a7)                                    # 默认对应R的character类型
[1] "abc"   "12345"
[1] "character"
> StringVector_type(c('abc',123.5, NA, TRUE))
[1] "abc"   "123.5" NA      "TRUE" 

# Numeric向量
> a8<-NumericVector_type(rnorm(5))
> a8;class(a8)                                    # 默认对应R的numeric类型
[1] -0.2813472 -0.2235722 -0.6958443 -1.5322172  0.5004307
[1] "numeric"
> NumericVector_type(c(rnorm(5),NA,TRUE))         # NA不处理,TRUE为1
[1]  0.1700925  0.5169612 -0.3622637  1.0763204 -0.5729958
[6]         NA  1.0000000

# Integer向量
> a9<-IntegerVector_type(c(11,9.9,1.2))           # 直接去掉小数位
> a9;class(a9)                                    # 默认对应R的integer类型
[1] 11  9  1
[1] "integer"
> IntegerVector_type(c(11,9.9,1.2,NA,TRUE))       # NA不处理,TRUE为1
[1] 11  9  1 NA  1

# Double向量,同Numeric向量
> a10<-DoubleVector_type(rnorm(5))
> a10;class(a10)                                  # 默认对应R的numeric类型
[1]  0.9400947 -0.8976913  0.2744319 -1.5278219  1.2010569
[1] "numeric"
> DoubleVector_type(c(rnorm(5),NA,TRUE))          # NA不处理,TRUE为1
[1]  2.0657148  0.2810003  2.1080900 -1.2783693  0.2198551
[6]         NA  1.0000000

# Logical向量 
> a11<-LogicalVector_type(c(TRUE,FALSE))
> a11;class(a11)                                  # 默认对应R的logical类型
[1]  TRUE FALSE
[1] "logical"
> LogicalVector_type(c(TRUE,FALSE,TRUE,0,-1,NA))  # NA不处理,0为FALSE, 非0为TRUE
[1]  TRUE FALSE  TRUE FALSE  TRUE    NA

 # Date向量 
> a12<-DateVector_type(c(Sys.Date(),as.Date('2016-10-10')))
> a12;class(a12)                                  # 默认对应R的Date类型
[1] "2016-08-01" "2016-10-10"
[1] "Date"
> DateVector_type(c(Sys.Date(),as.Date('2016-10-10'),NA,TRUE,FALSE))   # NA不处理,TRUE为1970-01-02, FALSE为1970-01-01
[1] "2016-08-01" "2016-10-10" NA           "1970-01-02"
[5] "1970-01-01"

 # Datetime向量 
> a13<-DatetimeVector_type(c(Sys.time(),as.POSIXct('2016-10-10')))
> a13;class(a13)                                  # 默认对应R的POSIXct类型
[1] "2016-08-01 20:05:25 CST" "2016-10-10 00:00:00 CST"
[1] "POSIXct" "POSIXt" 
> DatetimeVector_type(c(Sys.time(),as.POSIXct('2016-10-10'),NA,TRUE,FALSE))  # NA不处理
[1] "2016-08-01 20:05:25 CST" "2016-10-10 00:00:00 CST"
[3] NA                        "1970-01-01 08:00:01 CST"
[5] "1970-01-01 08:00:00 CST"

3.3 矩阵类型

矩阵类型,C++对应R语言的默认映射关系。C++的代码部分,如下所示:


// [[Rcpp::export]]
CharacterMatrix CharacterMatrix_type(CharacterMatrix x){
  return x;
}

// [[Rcpp::export]]
StringMatrix StringMatrix_type(StringMatrix x){
  return x;
}

// [[Rcpp::export]]
NumericMatrix NumericMatrix_type(NumericMatrix x){
  return x;
}

// [[Rcpp::export]]
IntegerMatrix IntegerMatrix_type(IntegerMatrix x){
  return x;
}

// [[Rcpp::export]]
LogicalMatrix LogicalMatrix_type(LogicalMatrix x){
  return x;
}

// [[Rcpp::export]]
ListMatrix ListMatrix_type(ListMatrix x){
  return x;
}

执行R语言调用


# Character矩阵
> a14<-CharacterMatrix_type(matrix(LETTERS[1:20],ncol=4))
> a14;class(a14)
     [,1] [,2] [,3] [,4]
[1,] "A"  "F"  "K"  "P" 
[2,] "B"  "G"  "L"  "Q" 
[3,] "C"  "H"  "M"  "R" 
[4,] "D"  "I"  "N"  "S" 
[5,] "E"  "J"  "O"  "T" 
[1] "matrix"                        

# String矩阵,同Character矩阵
> a15<-StringMatrix_type(matrix(LETTERS[1:20],ncol=4))
> a15;class(a15)
     [,1] [,2] [,3] [,4]
[1,] "A"  "F"  "K"  "P" 
[2,] "B"  "G"  "L"  "Q" 
[3,] "C"  "H"  "M"  "R" 
[4,] "D"  "I"  "N"  "S" 
[5,] "E"  "J"  "O"  "T" 
[1] "matrix"

# Numeric矩阵
> a16<-NumericMatrix_type(matrix(rnorm(20),ncol=4))
> a16;class(a16)
           [,1]       [,2]       [,3]       [,4]
[1,]  1.2315498  2.3234269  0.5974143  0.9072356
[2,]  0.3484811  0.3814024 -0.2018324  0.8717205
[3,] -0.2025285  2.1076947 -0.3433948  1.1523710
[4,] -1.4948252 -0.7724951 -0.7681800 -0.5406494
[5,]  0.4815904  1.4930873 -1.1444258  0.2537099
[1] "matrix"

# Integer矩阵 
> a17<-IntegerMatrix_type(matrix(seq(1,10,length.out = 20),ncol=4))
> a17;class(a17)
     [,1] [,2] [,3] [,4]
[1,]    1    3    5    8
[2,]    1    3    6    8
[3,]    1    4    6    9
[4,]    2    4    7    9
[5,]    2    5    7   10
[1] "matrix"

# Logical矩阵 
> a18<-LogicalMatrix_type(matrix(c(rep(TRUE,5),rep(FALSE,5),rnorm(10)),ncol=4))
> a18;class(a18)
     [,1]  [,2] [,3] [,4]
[1,] TRUE FALSE TRUE TRUE
[2,] TRUE FALSE TRUE TRUE
[3,] TRUE FALSE TRUE TRUE
[4,] TRUE FALSE TRUE TRUE
[5,] TRUE FALSE TRUE TRUE
[1] "matrix"

# List矩阵,支持多类型的矩阵
> a19<-ListMatrix_type(matrix(rep(list(a=1,b='2',c=NA,d=TRUE),10),ncol=5))
> a19;class(a19)
     [,1] [,2] [,3] [,4] [,5]
[1,] 1    1    1    1    1   
[2,] "2"  "2"  "2"  "2"  "2" 
[3,] NA   NA   NA   NA   NA  
[4,] TRUE TRUE TRUE TRUE TRUE
[5,] 1    1    1    1    1   
[6,] "2"  "2"  "2"  "2"  "2" 
[7,] NA   NA   NA   NA   NA  
[8,] TRUE TRUE TRUE TRUE TRUE
[1] "matrix"

3.4 其他数据类型

其他数据类型包括了,R语言特有的数据类型数据框(data.frame),环境空间(Environment)S3,S4,RC等的对象类型。


// [[Rcpp::export]]
Date Date_type(Date x){
  return x;
}

// [[Rcpp::export]]
Datetime Datetime_type(Datetime x){
  return x;
}

// [[Rcpp::export]]
S4 S4_type(S4 x){
  return x;
}

// [[Rcpp::export]]
RObject RObject_type(RObject x){
  return x;
}

// [[Rcpp::export]]
SEXP SEXP_type(SEXP x){
  return x;
}

// [[Rcpp::export]]
Environment Environment_type(Environment x){
  return x;
}

执行R语言调用


# data.frame类型
> a19<-DataFrame_type(data.frame(a=rnorm(3),b=1:3))
> a19;class(a19)
           a b
1 -1.8844994 1
2  0.6053935 2
3 -0.7693985 3
[1] "data.frame"

# list类型 
> a20<-List_type(list(a=1,b='2',c=NA,d=TRUE))
> a20;class(a20)
$a
[1] 1
$b
[1] "2"
$c
[1] NA
$d
[1] TRUE
[1] "list"

# Date类型
> a21<-Date_type(Sys.Date())
> a21;class(a21)
[1] "2016-08-01"
[1] "Date"
> Date_type(Sys.time())                # 不能正确处理POSIXct类型的数据
[1] "4026842-05-26"

# POSIXct类型 
> a22<-Datetime_type(Sys.time())
> a22;class(a22)
[1] "2016-08-01 20:27:37 CST"
[1] "POSIXct" "POSIXt" 
> Datetime_type(Sys.Date())            # 不能正确处理Date类型的数据
[1] "1970-01-01 12:43:34 CST"

# S3面向对象类型,对应S4的类型定义
> setClass("Person",slots=list(name="character",age="numeric"))
> s4<-new("Person",name="F",age=44)
> a23<-S4_type(s4)
> a23;class(a23)
An object of class "Person"
Slot "name":
[1] "F"
Slot "age":
[1] 44
[1] "Person"
attr(,"package")
[1] ".GlobalEnv"

# S3面向对象类型 ,没有对应的类型,通过RObject来传值
> s3<-structure(2, class = "foo")
> a24<-RObject_type(s3)
> a24;class(a24)
[1] 2
attr(,"class")
[1] "foo"
[1] "foo"

# RObject也可以处理S4对象
> a25<-RObject_type(s4)
> a25;class(a25)
An object of class "Person"
Slot "name":
[1] "F"
Slot "age":
[1] 44
[1] "Person"
attr(,"package")
[1] ".GlobalEnv"

# RObject也可以处理RC对象 
> User<-setRefClass("User",fields=list(name="character"))
> rc<-User$new(name="u1")
> a26<-RObject_type(rc)
> a26;class(a26)
Reference class object of class "User"
Field "name":
[1] "u1"
[1] "User"
attr(,"package")
[1] ".GlobalEnv"

# RObject也可以处理function类型
> a27<-RObject_type(function(x) x+2)
> a27;class(a27)
function(x) x+2
[1] "function"

# environment类型
> a28<-Environment_type(new.env())
> a28;class(a28)
<environment: 0x0000000015350a80>
[1] "environment"

# SEXP为任意类型,通过具体调用时再进行类型判断
> SEXP_type('fdafdaa')
[1] "fdafdaa"

> SEXP_type(rc)
Reference class object of class "User"
Field "name":
[1] "u1"

> SEXP_type(data.frame(a=rnorm(3),b=1:3))
           a b
1 -0.5396140 1
2  0.1694799 2
3 -1.8818596 3

> SEXP_type(function(x) x+2)
function(x) x+2

最后总结一下,R和Rcpp中类型对应的关系。

C++类型 R类型
char character
int integer
double numeric
bool logical
Rcpp::Date Date
Rcpp::Datetime POSIXct
Rcpp::CharacterVector character
Rcpp::StringVector character
Rcpp::NumericVector numeric
Rcpp::IntegerVector integer
Rcpp::DoubleVector numeric
Rcpp::LogicalVector logical
Rcpp::DateVector Date
Rcpp::DatetimeVector POSIXct
Rcpp::CharacterMatrix matrix
Rcpp::StringMatrix matrix
Rcpp::NumericMatrix matrix
Rcpp::IntegerMatrix matrix
Rcpp::LogicalMatrix matrix
Rcpp::ListMatrix matrix
Rcpp::DataFrame data.frame
Rcpp::List list
Rcpp::S4 S4
Rcpp::Environment environment
Rcpp::RObject 任意类型
Rcpp::SEXP 任意类型

本文简单地介绍了通过R语言Rcpp包调用C++程序的一种方法,调用的关键点就在于数据类型的匹配,而从保证R语言和C++之间的数据传输。从上面测试来看,R语言中的所有数据类型,都可以通过Rcpp包进行映射到C++的程序中。接下来,我们就可以根据自己的需求,把一些更关注的性能的程序放到C++中来实现,从而提高计算效率。

转载请注明出处:
http://blog.fens.me/r-cpp-rcpp

打赏作者