Большие циклы зависают в R?
В дополнение к тому, что добавили несколько других, вы можете сойти с ума, просто используя простой класс CSS без PHP, без кода jQuery , просто с простым HTML и CSS.
Создайте класс CSS и добавьте его в свой якорь. Код ниже.
.button-link {
height:60px;
padding: 10px 15px;
background: #4479BA;
color: #FFF;
-webkit-border-radius: 4px;
-moz-border-radius: 4px;
border-radius: 4px;
border: solid 1px #20538D;
text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.4);
-webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.4), 0 1px 1px rgba(0, 0, 0, 0.2);
-moz-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.4), 0 1px 1px rgba(0, 0, 0, 0.2);
box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.4), 0 1px 1px rgba(0, 0, 0, 0.2);
}
.button-link:hover {
background: #356094;
border: solid 1px #2A4E77;
text-decoration: none;
}
Press Here to Go
Вот и все. Это очень легко сделать, и вы можете быть настолько креативными, насколько захотите. Вы контролируете цвета, размер, формы (радиус) и т. Д. Более подробно см. На сайте, где я нашел это на .
5 ответов
Циклы For в R заведомо медленные, но здесь есть еще одна проблема. Намного быстрее заранее выделить вектор результатов res, а не добавлять к res на каждой итерации.
Ниже мы можем сравнить скорость вышеприведенной версии с версией, которая просто начинается с вектора res длины N и изменяет i-й элемент во время цикла.
fn1 <- function(N) {
res <- c()
for (i in 1:N) {
x <- rnorm(2)
res <- c(res,x[2]-x[1])
}
res
}
fn2 <- function(N) {
res <- rep(0,N)
for (i in 1:N) {
x <- rnorm(2)
res[i] <- x[2]-x[1]
}
res
}
> N <- 50000
> system.time(res1 <- fn1(N))
user system elapsed
6.568 0.256 6.826
> system.time(res2 <- fn2(N))
user system elapsed
0.452 0.004 0.496
Кроме того, как указывает Шарпи , мы можем сделать это немного быстрее, используя функции R, такие как apply (или его родственники, sapply и lapply ).
fn3 <- function(N) {
sapply( 1:N, function( i ){ x <- rnorm(2); return( x[2] - x[1] ) } )
}
> system.time(res3 <- fn3(N))
user system elapsed
0.397 0.004 0.397
Иногда цикл не нужен. Поскольку rnorm дает образец iid (теоретически), вы получите тот же результат (выборка
XY , где X и Y равны N (0,1)), выполнив:
res <- rnorm(N)-rnorm(N)
Продолжая мой комментарий к ответу chris_dubois, вот некоторая информация о времени:
> system.time(res <- rnorm(50000) - rnorm(50000))
user system elapsed
0.06 0.00 0.06
Сравните это с fn3 из того же ответа:
> system.time(res3 <- fn3(50000))
user system elapsed
1.33 0.01 1.36
Первое, что следует заметить, это то, что мой ноутбук медленнее, чем Машина chris_dubois. :)
Второй и более важный момент заключается в том, что векторный подход, вполне применимый здесь, на порядок быстрее. (Также на это указывает Ричи Коттон в комментарии к тому же ответу.)
Это подводит меня к заключительному пункту: это миф , что применимо , и его друзья очень много быстрее, чем для циклов в R. Они находятся в одном порядке в большинстве измерений, которые я видел. Потому что они просто для циклов за кадром. См. Также этот пост:
http://yusung.blogspot.com/2008/04/speed-issue-in-r-computing-apply-vs. html
По словам профессора Брайана Рипли, «apply () - это просто оболочка для цикла». Единственное преимущество использования apply () состоит в том, что он делает ваш код более аккуратным!
Именно так. Вам следует использовать apply , если он более выразительный , особенно если вы программируете в функциональном стиле. Не потому, что так быстрее.
Возможно, наиболее эффективной заменой вашей функции будет просто:
fn <- function(n) rnorm(N,0,sqrt(2))
, что в два раза быстрее, чем получение разницы нормальных переменных iid. В более общем плане, если ваша цель - запустить простое моделирование, предварительное выделение векторов / массивов и вызовы собственных функций значительно ускорят процесс.
Если вы хотите выполнить моделирование Монте-Карло для статистических оценок (например, MCMC), R имеет несколько собственных пакетов. Для общего стохастического моделирования я не знаю пакетов R, но вы можете попробовать Simpy ( http://simpy.sourceforge.net/ ), что отлично.
Эффективность циклов в R может быть значительно увеличена за счет использования функций применения, которые по существу обрабатывают целые векторы данных одновременно, а не циклически их просматривают. В показанном выше цикле на каждой итерации выполняются две основные операции:
# A vector of two random numbers is generated
x <- rnorm( 2 )
# The difference between those numbers is calculated
x[2] - x[1]
В этом случае подходящей функцией будет sapply () . sapply () работает со списком объектов, например вектором, сгенерированным оператором цикла 1: N , и возвращает вектор результатов:
sapply( 1:N, function( i ){ x <- rnorm(2); return( x[2] - x[1] ) } )
Обратите внимание, что значение индекса i доступен во время вызова функции и последовательно принимает значения между 1 и N , однако в этом случае это не требуется.
Попадание в систему привычка распознавать, где применить можно использовать вместо для - очень ценный навык - многие библиотеки R для параллельных вычислений обеспечивают распараллеливание plug-and-play с помощью функций apply . Использование apply часто позволяет получить доступ к значительному увеличению производительности в многоядерных системах с нулевым рефакторингом кода.
1: N , и возвращает вектор результатов:
sapply( 1:N, function( i ){ x <- rnorm(2); return( x[2] - x[1] ) } )
Обратите внимание, что значение индекса i доступно во время вызова функции и последовательно принимает значения между 1 и N , однако в данном случае это не требуется.
Привыкание распознавать, где применяется можно использовать вместо для - очень ценный навык - многие библиотеки R для параллельных вычислений обеспечивают распараллеливание plug-and-play с помощью функций apply . Использование apply часто позволяет получить доступ к значительному увеличению производительности в многоядерных системах с нулевым рефакторингом кода.
1: N , и возвращает вектор результатов:
sapply( 1:N, function( i ){ x <- rnorm(2); return( x[2] - x[1] ) } )
Обратите внимание, что значение индекса i доступно во время вызова функции и последовательно принимает значения между 1 и N , однако в данном случае это не требуется.
Привыкание распознавать, где применяется можно использовать вместо для - очень ценный навык - многие библиотеки R для параллельных вычислений обеспечивают распараллеливание plug-and-play с помощью функций apply . Использование apply часто позволяет получить доступ к значительному увеличению производительности в многоядерных системах с нулевым рефакторингом кода.
sapply( 1:N, function( i ){ x <- rnorm(2); return( x[2] - x[1] ) } )
Обратите внимание, что значение индекса i доступно во время вызова функции и последовательно принимает значения между 1 и N , однако в в этом случае.
Привыкание распознавать, где применить можно использовать вместо , поскольку - очень ценный навык - многие библиотеки R для параллельных вычислений обеспечивают распараллеливание plug-and-play через применяются функции . Использование apply часто позволяет получить доступ к значительному увеличению производительности в многоядерных системах с нулевым рефакторингом кода.
sapply( 1:N, function( i ){ x <- rnorm(2); return( x[2] - x[1] ) } )
Обратите внимание, что значение индекса i доступно во время вызова функции и последовательно принимает значения между 1 и N , однако в в этом случае.
Привыкание распознавать, где применить можно использовать вместо , поскольку - очень ценный навык - многие библиотеки R для параллельных вычислений обеспечивают распараллеливание plug-and-play через применяются функции . Использование apply часто позволяет получить доступ к значительному увеличению производительности в многоядерных системах с нулевым рефакторингом кода.
Привыкание распознавать, где применить можно использовать вместо , поскольку - очень ценный навык - многие библиотеки R для параллельных вычислений обеспечивают распараллеливание по принципу «plug-and-play» через ] применить функции. Использование apply часто позволяет получить доступ к значительному увеличению производительности в многоядерных системах с нулевым рефакторингом кода.
Привыкание распознавать, где применить можно использовать вместо , поскольку - очень ценный навык - многие библиотеки R для параллельных вычислений обеспечивают распараллеливание plug-and-play через ] применить функции. Использование apply часто позволяет получить доступ к значительному увеличению производительности в многоядерных системах с нулевым рефакторингом кода.