风险均摊 on 格物堂

善用向量化提升R语言的计算性能

Sat, 08 Mar 2014 00:00:00 +0000

用R 语言用的久了，渐渐发现 R 语言的世界里有很多黑魔法。其中一个黑魔法是向量化运算。向量化运算可以说是R语言区别于其它语言的特质之一，善用向量化运算不仅能有效降低代码的冗余度，还能显著提升代码的运算效率。遗憾的是，很多接触过其它编程语言的人未能掌握这一特性使得他们经常诟病R语言运算效率低下。这里给看官们举个例子来体会下。

想必大家都遇到过替换向量元素的情况。比如，我们有下面这样一个数据框，维度是1200000×2：

n = 1200000
df = data.frame(values = rnorm(n), 
 ID = rep(LETTERS[1:3], each = n/3),
 stringsAsFactors = FALSE)
head(df)

## values ID
## 1 1.8442348 A
## 2 -0.5089413 A
## 3 -0.8743655 A
## 4 0.7824285 A
## 5 -1.2115204 A
## 6 -1.4914611 A

tail(df)

## values ID
## 1199995 1.753660616 C
## 1199996 -0.007581797 C
## 1199997 -0.635219385 C
## 1199998 -1.437210958 C
## 1199999 -0.101465502 C
## 1200000 0.152135010 C

假设要把df$ID中的A替换为“A公司”，B和C类似。怎么做呢？一个常用的解决方案是利用if…for写循环。代码是这样的：

translator_if_for = function(input_vector) {
 output_vector = input_vector
 for(index in seq_along(input_vector)) {
 if(input_vector[index] == 'A') {
 output_vector[index] = 'A公司'
 } else if(input_vector[index] == 'B') {
 output_vector[index] = 'B公司'
 } else if(input_vector[index] == 'C') {
 output_vector[index] = 'C公司'
 } 
 } 
 return(output_vector)
}

dum_if_for = translator_if_for(df$ID)
head(dum_if_for)
tail(dum_if_for)

用rbenchmark包测试下上述操作需要的时间：

library(rbenchmark)
res = benchmark(if_for_solution = translator_if_for(df$ID),
 columns= c("test","replications","elapsed","relative","user.self","sys.self"),
 replications = 10)
 res

 test replications elapsed relative user.self sys.self
1 if_for_solution 10 69.63 1 69.48 0

上面这段代码的缺点是时间久，而且看起来一点都不简洁。那么，是否有更好点的解决方案呢？Absolutely！而且不止一种。比较常用的替代方案是借助 apply族函数（apply族函数是R语言中避免编写显式循环的一个trick）。在用apply族函数之前，得先构造一个辅助函数。构造函数之前不妨先想想我们的操作逻辑，我们想做的事情是这样的，对于df$ID中的某个元素，如果元素是A其就变成A公司，B变成B公司，C变成C公司。这其实可以用switch来实现。对所有元素进行依次进行判断就可以了，针对所有元素进行判断这个过程可以交给sapply函数来完成，于是有下面的代码：

 translator_function = function(element) {
 switch(element,
 A = 'A公司',
 B = 'B公司',
 C = 'C公司')
 }
 
 dum_switch_sapply = sapply(df$ID, translator_function)
 head(dum_switch_sapply)
 tail(dum_switch_sapply)

代码看起来更简洁，看看操作结果是否一致：

all.equal(dum_if_for, dum_switch_sapply, check.attributes = FALSE)

看看这段代码需要的时间：

 res = benchmark(function_solution = sapply(df$ID, translator_function),
 columns= c("test","replications","elapsed","relative","user.self","sys.self"),
 replications = 10)
 res

 test replications elapsed relative user.self sys.self
1 function_solution 10 64.58 1 64.1 0.24

可以看到时间也有所减少。But..这就是结束吗？操作效率是有提升，但提升的一点都不明显啊！？别急，我们还有杀手锏——向量化运算！先上代码，再慢慢解释逻辑。

 translator_vector = c(A = 'A公司',
 B = 'B公司',
 C = 'C公司')
 dum_vectorized = translator_vector[df$ID]
 head(dum_vectorized)
 tail(dum_vectorized)

看看结果是否一样：

all.equal(dum_vectorized, dum_switch_sapply, check.attributes = FALSE)

完全一样。但是看起来无疑简洁了很多。那么，从耗时角度讲呢？我们看一看：

 res = benchmark(vector_solution = translator_vector[df$ID],
 columns= c("test","replications","elapsed","relative","user.self","sys.self"),
 replications = 10)
 res

 test replications elapsed relative user.self sys.self
1 vector_solution 10 1.13 1 1.06 0.03

时间大大减少了。把三种方案的耗时放到一起看一看：

 res = benchmark(if_for_solution = translator_if_for(df$ID),
 function_solution = sapply(df$ID, translator_function),
 vector_solution = translator_vector[df$ID],
 columns= c("test","replications","elapsed","relative","user.self","sys.self"),
 replications = 10)
 res

 test replications elapsed relative user.self sys.self
2 function_solution 10 71.51 87.207 70.95 0.42
1 if_for_solution 10 69.89 85.232 69.34 0.25
3 vector_solution 10 0.82 1.000 0.75 0.08

向量化运算无论在代码简洁度还是在效率上完爆前两种方案。缺点是操作逻辑十分巧妙，可能不是那么容易理解。这里简单解释一下：

上面的translator_vector是个有名字的向量：

 translator_vector = c(A = 'A公司',
 B = 'B公司',
 C = 'C公司')
 translator_vector

names(translator_vector)

因此，可以通过元素的名字对元素进行索引。例如：

translator_vector["A"]
translator_vector["B"]
translator_vector[c("A","B")]

而df$ID刚好是一个由translator_vector向量的元素名字组成的向量。因此,代码：

translator_vector[df$ID]

就相当于一个索引操作，其结果得到的恰好是translator_vector中对应的元素，这也就相当于对向量元素进行了替换。

说说风险均摊投资组合的构建方法

Tue, 14 Jan 2014 00:00:00 +0000

引子

构建股票投资组合时，在筛选出备选股票之后，要解决的另外一个问题是确定备选股票在投资组合中的权重。我们可以用一个向量来表示：

$$ w=\left(w_1,w_2,…,w_n \right) $$

其中， $\sum_{i=1}^nw_{i}=1,i=1,2,...,n$ 。

显然，权重的可选集是个无限集合。如果想选取其中一个作为最优权重，那得先确定一个判断最优与否的方法。耳熟能详的方法自然是收益-风险法，即如果一个权重能够使投资组合的收益最大、风险最小，那么，它就是好的。如果用标准差来刻画风险的话，就有下面的评价函数:

$$ U(R,\sigma) $$

其中， $\frac{\partial U\left(\cdot\right)}{\partial R}\gt 0$ ， $\frac{\partial U\left(\cdot\right)}{\partial\sigma}\lt 0$。

$U\left(\cdot\right)$ 最简单的形式如下：

$$ U_p = aR_{p} + b \sigma _{p} $$

其中， $a\gt 0$ ， $b\le 0$ ； $R_{p}$ 是组合的收益率， $\sigma_{p}$ 是组合的标准差。显然：

$$ R_{p} = w’R $$

$$ \sigma_p = w’Cw $$

其中， $R=(R_1,R_2,...,R_n)$ 是组合中各证券的收益率， $C$ 是组合中各证券的收益率的协方差矩阵。

把 $R_{p}$ 和 $\sigma_p$ 带入 $U_p$ ，解出令 $U_p$ 最小的 $w$ 即可。

当然，也有其它理念。比如下面要说的风险均摊。风险均摊是指选出来这样一个权重，使得其确定的投资组合中各个证券的风险占证券投资总的风险的比例是相同的。有些拗口，直接看下面的公式。

风险均摊的理论基础及公式

由前面的公式可知：

$$ \sigma_p = wCw’=wC \times (w_1,w_2,…,w_n)’=\sum_{i=1}^n wC_{\cdot i}w_i $$

上面可以看到证券组合的风险相当于是 $wC_{\cdot i}$ 的加权组合，权重是 $w=(w_1,w_2,...,w_n)$ 。所谓风险均摊，就是令 $wC_{\cdot i}w_i=wC_{\cdot j}w_j$ 。显然，确定一个权重 $w$ 使得证券组合的风险得以均摊等同于找到一个权重 $w$ 使得下式最小：

$$ \sum_{j=1}^n \sum_{i=1}^n \left[ wC_{\cdot i}w_i-wC_{\cdot j}w_j \right]^2 $$

这是一个比较简单的优化问题，在 R 软件里面很容易得到结果。

用 R 实现风险均摊优化器

# 模拟获取数据
require(quantmod);
x=getSymbols("000635.sz",from="2013-01-01",auto.assign=FALSE)
y=getSymbols("000547.sz",from="2013-01-01",auto.assign=FALSE)
z=getSymbols("600241.ss",from="2013-01-01",auto.assign=FALSE)
ret_mat <- cbind(dailyReturn(x),dailyReturn(y),dailyReturn(z))
ret_mat <- na.omit(ret_mat)

# 定义目标函数

ff <- function(w,ret_mat){
 cov_mat <- cov(ret_mat);
 w=c(w,1-sum(w));
 len <- length(w);
 w_mat <- matrix(rep(w,time=len),nr=len,byrow=TRUE);
 diag_mat <- diag(w);
 res <- 2*len*as.vector(t(diag(w_mat%*%cov_mat%*%diag_mat))%*%diag(w_mat%*%cov_mat%*%diag_mat))-2*(sum (diag(w_mat%*%cov_mat%*%diag_mat)))^2;
 return(res);
 } 
 
# 优化目标函数

w <- optim(c(0.3,0.3),ff,ret_mat=ret_mat)$par;

# 查看权重

w=c(w,1-sum(w));
w = c(w,1-w[1]-w[2])