s*****n
发帖数: 2174 | 1 这些apply的overhead cost比较高, 所以对于循环体简单的loop, 未必会比for loop快
, 很多时候更慢, 比如:
> system.time(for (i in 1:100000) {1+1})
[1] 0.11 0.00 0.11 NA NA
> system.time(lapply(1:100000, function(i) {1+1}))
[1] 0.18 0.00 0.19 NA NA
如果仅仅是用apply来代替循环, 意义可能不是很大. 大多数apply都是用于某种直接的
计算, 很方便.
在几个apply当中, lapply是最基本的, sapply, tapply, apply本质上都是lapply的包
装, 大多数时候lapply稍快一些, 但是另外几个往往看上去更简洁. 比如:
> data <- data.frame(
+ id = rep(1:1000, each = 1000),
+ value = rnorm(1000 * 1000)
+ )
>
> system.time(unlist(lapply(spl |
|
y*******y
发帖数: 163 | 2 之前看到过很多次说R里面for loop非常的不efficient, 很多人建议用apply，sapply
，lapply...
可是我最近做的一个simulation看来好像不是这样的, 用两个for loop (1000*1000)
写的程序运行了5个小时, 每个循环都是用lm fit model. 改成sapply和replicate以后
只提高了两三分钟...
有大牛给解答一下吗?多谢 |
|
n*********e
发帖数: 318 | 3 再多总结一条：
"lapply" - always returns a list (no matter what function is) - also works
right after "split" and takes two parameters
因此， "lapply" and "sapply" 最相近， 只是"sapply" 更灵活 （"lapply" always
returns a list; "sapply" can return either list or vector）
----------------------------------------------------------------
> t
customer_id product_id date dt
1 11111 634578 11/12/2011 2020-11-12
2 11111 987654 11/12/2011 2020-11-12
3 11111 678978 11/12/2011 2020... 阅读全帖 |
|
s*****n
发帖数: 2174 | 4 lapply(split(data[, 1:2], list(data[,3], data[,4])), colSums)
就可以了.
上面有人提到了by( ), 也不错, 非常方便.
我以前还真不知道.
不过如果你希望继续应用这个东西的结果的话,
建议用lapply, 因为它的输出是list, 很容易后续操作.
还有就是lapply+split的执行效率要比tapply稍高一些.
> system.time( for (i in 1:2000) by(data[,1:2],data[,3:4],colSums))
[1] 6.58 0.01 6.05 NA NA
> system.time( for (i in 1:2000) lapply(split(data[, 1:2], list(data[,3],
data[,4])), colSums))
[1] 5.52 0.00 5.20 NA NA |
|
s*****n
发帖数: 2174 | 5 哦, 看明白你最后那个问题了, 你可能是希望这样
data <- data.frame(
a=c(1,2,1,2),
b=c(2,3,4,5),
c=c(3,3,4,4))
根据c的不同取值, 同时对a和b应用某函数, 比如求和, 输出是这样的
a b (c=3)
3 5
a b (c=4)
3 9
如果是这样的话, tapply是不行的, 因为tapply的第一参数只能是vector, 不能是矩阵
. 不过你可以人为实现, 先用split函数把data frame分解成小块成为list, 然后应用
lapply和colSums函数.
> lapply(split(data[, 1:2], data[,3]), colSums)
$`3`
a b
3 5
$`4`
a b
3 9
实际上, tapply的优势在于多维度的计算, 而lapply和split更清晰灵活., 速度上更快
. |
|
o******6
发帖数: 538 | 6 ☆─────────────────────────────────────☆
qqzj (小车车) 于 (Wed Mar 18 18:18:12 2009) 提到:
今天看了看tapply的source code，发现是用了lapply来干活的。怪不得比apply慢。但
是却看不到lapply的code。也看不到stat::aggregate的code。请问这些个东西应该如
何去看呢？
☆─────────────────────────────────────☆
songkun (告别棒球场) 于 (Wed Mar 18 18:57:15 2009) 提到:
lapply 是 internal 的函数, 你可以看原始C code
默认路径是
your_R_folder/src/main/apply.c
里面有个 do_lapply
aggregate那个, 你用methods可以看到aggregate包装下的几个函数
> methods(aggregate)
[1] aggregate.data.frame aggregate.default aggreg |
|
s*****n
发帖数: 2174 | 7 apply, sapply, mapply 这些本质上都是lapply的衍生物.
用于不同情况.
apply主要用于对于矩阵进行某种行或列的计算.
sapply基本就是lapply, 只不过它会return矩阵, 而不是lapply那样return list. |
|
d*******1
发帖数: 854 | 8 ok, here is what i am doing:
result<- lapply(split(all,all$CHIPEXP_NAME),function(x) lm(logvalue~
treatment,x))
用lapply拿到result(是个 vector)
再用：
res<- sapply(result, function(x)
{fs<- summary(x)$fstatistic;pf(fs[1],fs[2],fs[3],lower
.tail=F)}
)
拿到每个by variable 的 p value, 我的问题是怎样拿到其他stat呢？比如parameter
estimtate, parameter stderr, degree of freedom.....etc? 如何看到result 的结
构呢？
用names(result)只是得到所有by variable的值， 因为我这个result是由lapply产生
的一个vector, 每个by varaible的值都成了colum |
|
f***a
发帖数: 329 | 9 照例，还是我先胡说几句，:-)
在R里面能不用for loop就不应该用，尽量用vectorize的方式搞定一切。
对matrix/data.frame的row or col做运算，就用apply；（btw, same for array）
要对list, data.frame(essentially it is a list), vector的element做运算就用
lapply, sapply；
对不同id做运算，用tapply
下面是我的问题。
1）
# Way I:
for(i in 1:n){
res[i] <- myfunction(a[i], b[i], c[i])
}
# Way II:
res <- apply(cbind(a,b,c), 1, function(t)
myfunction(t[1], t[2], t[3])
)
这两种方法equivalent还是way II好一些呢？
2)
# Way I:
for(i in 1:n){
input <- i
...... # some heavy calculation
res[i] <- output
}
... 阅读全帖 |
|
q**j
发帖数: 10612 | 10 我今天又试了一下，接近成功了一点。
y = unlist(lapply(Data$Date, seq,length=12))
z = matrix(y,nrow=8640,ncol=12,byrow=T)
可以生成这样的一个矩阵。
但是有几个新问题。
1. lapply不让我用by="1 month"这样的参数，所以我得到了12个连续的日子，而不是
月份。
2. 生成的z是数字而非日期。我检查了，这个数字是正确从19700101开始的天数，请问
如何把这样一个数字矩阵转换成为日期矩阵？
最后一个小问题：as.date和as.Date有什么区别？看了一遍manual没有什么概念。 |
|
q**j
发帖数: 10612 | 11 多谢指点，但是我实在忍不住要说：this does not make any sense。
1. 既然seq可以跟一个by = "1 month"的参数，为什么lapply不行？lapply就是叫 一
下seq这个function来干活嘛。如果这个的确做不到就真是岂有此理了。
2. SAS表示日期和R近似，都是从某天起的多少天。在SAS里面可以简单的format一下就
好了。R里面居然没有这个功能，我感到非常非常奇怪。但是这个是个小问题。以后我
学你好了。永远用character。
3. 我用了一个date package。好像as.date是这个里面的。多谢了。
月/ |
|
s*****n
发帖数: 2174 | 12 1. lapply 是list apply在这里调用了seq函数, 那么每个调用, 其实返回的是一个
vector. 这些vector之间组成一个list, 而不是矩阵. 你可以试试这段code. list 是R
里面很灵活的一种数据结构, 习惯这种思维方式, 很好用.
add1m <- function(date){
return(seq(as.Date(date), by = "1 month", length = 12))
}
test1 <- c("2001-01-01", "2003-12-01")
lapply(test1, add1m)
2. R 里面一样可以转换. 你可以用
as.Date(25273, origin = "1970-01-01")
来把整数转换为距离基准日期相应天数的日期. 不过R很多时候过于smart, 会帮助你把
日期转换成字符, 或者整数什么的, 而你并不需要它这样做. 这就是为什么我建议你用
character. 字符串是固定的.
3. 作为一个建议, 尽量不要把变量存储为date, 或者 factor 形式的东西, 推荐用
charact |
|
q**j
发帖数: 10612 | 13 我找了找还有一个mapply结果和sapply（大概就是lapply）是一样的。这样堆apply可
真够人看的。
lapply(sapply)
tapply
mapply
另外这个"by" type的object怎么manipulate呢？我看了看manual，没看出头绪。
（另外哪个保存factor vector的问题也帮忙给看看吧。）
done! find what i need!
data <- data.frame(
a=c(1,2,1,2),
b=c(2,3,4,5),
c=c(3,3,4,4),
d=c(1,2,1,2))
myagg = aggregate(data[,1:2],by=list(data[,3], data[,4]),FUN=sum,na.rm=TRUE)
> myagg
Group.1 Group.2 a b
1 3 1 1 2
2 4 1 1 4
3 3 2 2 3
4 4 2 2 5
why do they have to bury it do dee |
|
s*****n
发帖数: 2174 | 14 如果你的初始点就是 list1 和 list2, 估计必须要写循环. lapply只能对单一list的
元素应用某个函数, 好像不能对不同list的对应元素应用函数.
如果list1和list2是你自己生成的, 那你可以在生成他们的步骤里面做一些工作, 把他
们放入同一个object里面, 就可以在后续步骤使用lapply了. 比如做一个大的list a,
每个元素A[[i]] 是一个以 list1[[i]] 和 list2[[i]] 组成的小list. 或者干脆就给
list1[[i]] 定义一个attributes 叫 delete, 赋值为 list2[[i]].
反正原则就是尽量把list1 和 list2 给放入同一个object里面. |
|
q**j
发帖数: 10612 | 15 你自己写个函数估计就可以了吧。这个不是如何用lapply()的问题。而是如何specify和
lapply一起用的函数的问题。我晚上试试看。
, |
|
y****2
发帖数: 34 | 16 data <- matrix(c(1 ,1 ,2, 2, 1, 3, 4, 2,1, 5, 6, 3,2, 7, 8, 3,2, 9, 10, 4),
ncol=4, byrow=T)
colnames(data) <- c("id", "x1", "x2", "e")
### step1:
data[,2:3] <- data[,2:3]*data[,4]
data1 <- data[,1:3]
### step2:
data2 <- aggregate(data1[,2:3], list(id=data1[,1]), sum)
### step3:
data3 <- split(data2[,2:3], f=list(data2[,1]))
data3 <- lapply(data3, as.vector, "numeric")
mprod <- function(x){x %*% t(x)}
data4 <- lapply(data3, mprod)
### step4:
data5 <- 0
for(i in 1:length(data4)){
data5 <- data5 + |
|
s*****n
发帖数: 2174 | 17 tapply 里面的那个 for loop 只是一个预处理.
真正的核心是 lapply(split(X, group), FUN, ...)
lapply 是 internal 函数, implemented by C
速度会快很多.
楼主的那个问题, 基本上tapply是不二选择. 不需要任何library,
速度快, 而且具有推广性. |
|
s*****n
发帖数: 2174 | 18 Yes, actually lapply+split is a common way to do "for"-type loop, but in a
much more efficient way. Other "apply"s are just wrappers of lapply.
se |
|
F****n
发帖数: 3271 | 19 Yeah, you are right, but I think since
C code -> R loop too,
lapply == loop >= apply
In other words lapply is faster than apply but not necessarily better than
loop. |
|
D******n
发帖数: 2836 | 20 Ya, because people keep saying the apply family is faster, so i was
surprised to find out (see floor 17), apply alone is not C code(or other non
R script) based while other family members are.
just type apply in R , you can find out it is totally R code with a loop.
.....
else for (i in 1L:d2) {
tmp <- FUN(array(newX[, i], d.call, dn.call), ...)
if (!is.null(tmp))
ans[[i]] <- tmp
}
.....
for lapply it is like this
function (X, FUN, ...)
{
FUN <- match.fun(... 阅读全帖 |
|
s*****n
发帖数: 2174 | 21 单纯从looping本身， lapply()的确和for()没有本质差别。
不过写for loop难免要生成很多不必要的变量和步骤， 于是造成程序不efficient。
lapply是批量处理， 避免了单独定义很多不必要的变量。
programming |
|
m******r
发帖数: 1033 | 22 多谢回帖。 如果我根本不知道一个命令，如何输入这个命令？
R是我迄今见过最古怪的语言，完全找不到用户手册。 要是你老板让你学一门语言，比
如，spss, matlab, mysql, hive,你怎么办？ 我肯定
1.从官网下载用户手册
2.看看数据类型
3.都有什么函数（数值型，字符型）
4.看看例子
我学最流行的hive sql,也是这个思路，两个月以后就可以不依靠数据组的技术支持，
自己处理实际问题了。 （不久前有人说一天就学会了hive sql, 有点夸张，但也不是
没有可能。 原因很简单： 跑到https://cwiki.apache.org/confluence/display/Hive
/LanguageManual+UDF#LanguageManualUDF-DateFunctions 所有函数都写在里面了，
不懂hadoop那些命令？ 没关系，半天时间看看用户手册 https://hadoop.apache.org/
docs/r2.7.1/hadoop-project-dist/hadoop-hdfs/HDFSCommands.html 就可以。 只要
用过sql... 阅读全帖 |
|
m******r
发帖数: 1033 | 23 多谢回帖。 如果我根本不知道一个命令，如何输入这个命令？
R是我迄今见过最古怪的语言，完全找不到用户手册。 要是你老板让你学一门语言，比
如，spss, matlab, mysql, hive,你怎么办？ 我肯定
1.从官网下载用户手册
2.看看数据类型
3.都有什么函数（数值型，字符型）
4.看看例子
我学最流行的hive sql,也是这个思路，两个月以后就可以不依靠数据组的技术支持，
自己处理实际问题了。 （不久前有人说一天就学会了hive sql, 有点夸张，但也不是
没有可能。 原因很简单： 跑到https://cwiki.apache.org/confluence/display/Hive
/LanguageManual+UDF#LanguageManualUDF-DateFunctions 所有函数都写在里面了，
不懂hadoop那些命令？ 没关系，半天时间看看用户手册 https://hadoop.apache.org/
docs/r2.7.1/hadoop-project-dist/hadoop-hdfs/HDFSCommands.html 就可以。 只要
用过sql... 阅读全帖 |
|
l*******r
发帖数: 3799 | 24 in R:
library(quantmod) # A library for stock analysis
DJIA <- c("MMM", "AA", "AXP", "T", "BAC", "BA", "CAT", "CVX", "TRV", "KO", "
DD", "XOM", "GE", "CSCO", "HPQ", "HD", "IBM", "INTC", "JNJ", "JPM", "KFT", "
MCD", "MRK", "MSFT", "PFE", "PG", "UTX", "VZ", "WMT", "DIS")
getSymbols(DJIA) # Download historical data for Dow 30 stocks
getSymbols("^DJI") # Download historical data for Dow index
x <- do.call("rbind", lapply(DJIA, function(x) get(x)[, 4])) # Extract
close price
plot |
|
m*****n
发帖数: 3575 | 25 "我几乎从来不用apply，lapply倒是常用，那是为了避免自己手工初始化list。"
——好吧，你比我宽容，你只要R比C省事就满意了。 |
|
p***r
发帖数: 920 | 26 why dont you just you lapply instead? |
|
q**j
发帖数: 10612 | 27 多谢指点。两个问题。
1. 通常我的数据并不是这么整齐的。
就是说第二行的第一个日子并不一定是第一行的1年以后。所以我想通过lapply或者其
他的方式来生成一个matrix。第一列和原数据一样，但是第二，第三列等等是原数列的
1，2，3 。。。个月以后。
2. 在把x转成matrix的时候，为什么要as.character？难道没有date型的matrix？
多谢指点。 |
|
s*****n
发帖数: 2174 | 28 1. lapply 是应用一个函数到每个向量的元素上, 可是 add one month 根本就不是一
个明确的函数. 这一点和add one day 很不一样. add one month 要根据不同的年/月/
日, 来确定加多少天. 所以恐怕你要自己写个函数来完成这个事情. 这个函数不算特别
简单, 要考虑的情况挺多的.
2. 这就是我之前为什么用了 as.character(), 强迫R把日期变成字符串来存储到矩阵
里面. 事实上, R里面的date, 就是整数而已. 变成矩阵的时候, 就按照整数显示了,
以后的操作不受影响, 但是显示看着不舒服. 一般我处理日期时间, 永远都是按照字符
串处理, 每次调用的时候, 如果需要的话, 再调用as.Date()
3. R 里面只有as.Date(), 没有as.date(). 只有date() 这个函数, 用于提取当前日期
和时间. 不过我一般都是只用 Sys.Date(), 只提取时间. |
|
l*******l
发帖数: 204 | 29 Please try first and then come here to ask. May you are trying to test songkun (告别棒球场).
lapply(split(data[, 1:2], data[,3:4]), colSums)
Here is another option.
by(data[,1:2],data[,3:4],colSums) |
|
q**j
发帖数: 10612 | 30 Thanks a lot. This is very nice. the lapply (by) approach will hide the
factors in the row names. this is quite inconvenient if i want to merge the
summary data later on with the raw data. ideally, i hope i can find
something like summarize but can process multiple vectors at once time and
keep the by values by default.
i am searching around now, but if somebody has a good idea, please let me
know. |
|
q**j
发帖数: 10612 | 31 1.多谢。这个我还是有些疑惑。如果两个变量其实是一样的值，但是format成为不同的
形式，我感觉这个办法不是非常robust。比如：一个是4， 一个是4.0。如果是字符串的
情况，如何保证trailing or leading blanks 不会坏事呢？请问这些情况是否会出现？
2. 这个lapply用的很好。但是我想知道在哪个情况下有没有办法vectorize这个loop。
也许以后会有用。 |
|
s*****n
发帖数: 2174 | 32 tapply (as well as other "apply"s, such as sapply, mapply, lapply, apply)
is a relatively efficient way to do looping in R.
You have to use it for sometime before you really understand and become
comfortable of it. It is not easy to explain briefly.
If you feel confused about how tapply works, you can write a loop. By using
explicit loop, the programming logic is clearer, but the program is usually
less efficient. |
|
s*****n
发帖数: 2174 | 33
看报错的信息, FUN要求以dat的每一个行作为input, 你定义的F要求两个input, 当然
不行了. 如果是为了求和的话
apply(dat,1,sum)
报错是肯定的 FUN 要求是
'FUN' must be a function (or the name of it) which expects at
least two arguments and which operates elementwise.
你定义的FF 是以向量形式运算的. 解决的办法是人为elementize, 比如:
> x <- 1:5
> FF1 <- function(a,b){
+ lapply(seq(along=a), function(t) sum(a[t] * x + b[t]))
+ }
> outer(1:2,4:6,FF1)
[,1] [,2] [,3]
[1,] 35 40 45
[2,] 50 55 60
这个 FF1 和你那个 FF 的区别是, FF1 是 elementwise 的, 而你的FF
是vectorwise的. |
|
f***a
发帖数: 329 | 34 看报错的信息, FUN要求以dat的每一个行作为input, 你定义的F要求两个input, 当然
不行了. 如果是为了求和的话
apply(dat,1,sum)
~~~~~~~~~~~~~~~~~~~~~~
不是为了求和，这只是个例子。就是FUN在这种有两column的input的情况下我不知道该
怎么办算方便。用for循环太慢了吧，能不能用apply实现呢？
报错是肯定的 FUN 要求是
'FUN' must be a function (or the name of it) which expects at
least two arguments and which operates elementwise.
你定义的FF 是以向量形式运算的. 解决的办法是人为elementize, 比如:
> x <- 1:5
> FF1 <- function(a,b){
+ lapply(seq(along=a), function(t) sum(a[t] * x + b[t]))
+ }
> outer(1:2,4:6,FF1)
[,1] [,2] [,3]
[1,] 35 40 45 |
|
q**j
发帖数: 10612 | 35 这个ddply是在R里面搞了一个loop来干活的。好像应该没有lapply（tapply）快吧？这
种重复建设其实是open source的一个大问题。 |
|
s*****n
发帖数: 2174 | 36 这些完全都可以用apply系列搞定.
你一开始那个问题, 用tapply()
求cumulative sum, 用lapply()或者sapply()
> a <- 1:10
> sapply(1:length(a), function(t) sum(a[1:t]))
[1] 1 3 6 10 15 21 28 36 45 55
具体format, 你自己试验一下就好了. |
|
D******n
发帖数: 2836 | 37 apply is operating on the matrix coloumn wise or row wise( u need to appoint)
s/lapply operates on an object element wise |
|
d*******1
发帖数: 854 | 38 这这里这个by可以用lapply什么的代替呢， 两者之间有什么区别？ |
|
D******n
发帖数: 2836 | 39 lapply(split(data,data$gene),function(x) lm(value~treatment,x)) |
|
p***r
发帖数: 920 | 40 so lapply do apply the function to a list, but you first should have a
list, otherwise, it will just take each column as a list? |
|
d*******1
发帖数: 854 | 41 那看来在我的情况下用by还是比较简单， 能不能总结下什么情况下用lapply呢？（还
有apply, sapply等等） |
|
d*******1
发帖数: 854 | 42 一点头绪：
result<- lapply(split(data,data$gene),function(x) lm(logvalue~treatment,x))
大概25分钟搞定， 我开始的错误在于在LM中用了data$logvalue， data$treatment |
|
d*******1
发帖数: 854 | 43 用了DASHAGEN的code计算如下：
result<- lapply(split(data,data$gene),function(x) lm(value~treatment,x))
但是结果的result是个list, 只有coefficient estimation 找不到p value, 用了
summary(result) 也不行, 结果如下：
> tail(summary(result))
Length Class Mode
AFFX-ThrX-3_at "13" "lm" "list"
AFFX-ThrX-5_at "13" "lm" "list"
AFFX-ThrX-M_at "13" "lm" "list"
AFFX-TrpnX-3_at "13" "lm" "list"
AFFX-TrpnX-5_at "13" "lm" "list"
AFFX-TrpnX-M_at "13" "lm" "list"
但是我知道一般的linear model是可以的：
> c1<-rnorm(100)
> |
|
D******n
发帖数: 2836 | 44 lapply(result,summary); |
|
d*******1
发帖数: 854 | 45 不过我还是想把所有的stat都弄出来， 我就不明白了：
res<- lapply(result, summary) 得到的还是list,
用res[1]展示stat是没问题：
> res[1]
$`1007_s_at`
Call:
lm(formula = logvalue ~ treatment, data = x)
Residuals:
Min 1Q Median 3Q Max
-0.2323 -0.1486 -0.0845 0.1602 0.4139
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 8.94030 0.09563 93.492 4.8e-16 ***
treatmentveh 0.32317 0.12520 2.581 0.0274 * |
|
D******n
发帖数: 2836 | 46 result<-lapply(1:nrow(data)-x+1,function(t) data[t:(t+x-1)]) |
|
j***3
发帖数: 142 | 47 Thanks goldmember, it is in the order if billions so I'd best avoid loop.
Thanks DaShagen, I think it might be the best solution.
an alternative is use rollapply in zoo package, but lapply is more
straightforward. |
|
h******e
发帖数: 6 | 48 unlist(lapply(split, function(x) {x[2]})) |
|
t**i
发帖数: 688 | 49 lapply(t,function(tt){read.table(tt,header=true,sep="\t")}) |
|
t**i
发帖数: 688 | 50 Day<-lapply(...)
Day[[1]] |
|
