标签: parallel-processing

我正在尝试并行化管道。在管道中有一个 tidyr 命令（“tidyr::complete”）。一旦并行运行，这就会分解代码，因为无法识别对象类。

dplyr 中是否有替代方法可以完成？

library(dplyr)
library(tidyr)
library(zoo)


test <- tibble(year=c(1,2,3,4,5,5,1,4,5),
               var_1=c(1,1,1,1,1,1,2,2,2), 
               var_2=c(1,1,1,1,1,2,3,3,3), 
               var_3=c(0,5,NA,15,20,NA,1,NA,NA))

max_year <- max(test$year,na.rm = T)
min_year <- min(test$year,na.rm = T)

串行

test_serial <- test %>% 
  group_by(var_1,var_2) %>% 
  complete(var_1, year = seq(min_year,max_year)) %>%
  mutate(
    var_3 = na.approx(var_3,na.rm = FALSE),
    var_3 = if(all(is.na(var_3))) NA else na.spline(var_3,na.rm = FALSE))

并行（失败）

devtools::install_github("hadley/multidplyr")
library(multidplyr)

cl <- new_cluster(2)
cluster_copy(cl, c("test","max_year","min_year"))
cluster_library(cl, c("dplyr","tidyr","zoo"))

test_parallel <- test %>% group_by(var_1,var_2) %>% partition(cl)
test_parallel <- test_parallel %>% 
  dplyr::group_by(var_1,var_2) %>% 
  tidyr::complete(var_1, year = seq(min_year,max_year)) %>%
  dplyr::mutate( …

所以，我知道标题中两种方法的区别，但不知道实际含义。

据我了解：如果您使用的 NUM_WORKERS 数量多于实际可用的核心数量，您将面临性能大幅下降，因为您的操作系统不断地来回切换，试图保持并行。不知道这有多真实，但我在某处从比我聪明的人那里读到了它。

在它的文档中os.cpu_count()说：

返回系统中 CPU 的数量。如果未确定则返回 None。该数字不等于当前进程可以使用的 CPU 数量。可用CPU的数量可以通过len(os.sched_getaffinity(0))获得

因此，我试图弄清楚“系统”指的是一个进程可使用的 CPU 数量是否多于“系统”中的 CPU 数量。

我只是想安全有效地实现multiprocessing.pool功能。所以这是我的问题总结：

以下内容有何实际意义：

NUM_WORKERS = os.cpu_count() - 1
# vs.
NUM_WORKERS = len(os.sched_getaffinity(0)) - 1

这-1是因为我发现，如果我尝试在处理数据时工作，我的系统的延迟会少很多。

我正在尝试按照此处的教程在我的图像集上使用预先训练的模板：https : //pytorch.org/tutorials/beginner/finetuning_torchvision_models_tutorial.html

只有当我运行我的代码并且控制台锁定时，我总是得到这个“错误”：

[W ParallelNative.cpp:206] Warning: Cannot set number of intraop threads after parallel work has started or after set_num_threads call when using native parallel backend (function set_num_threads)

预先感谢您的帮助，

我用 fastapi 和 uvicorn 进行了一项实验，但我不明白其结果。

关于代码

@app.get('/loadtest')
def root():
    time.sleep(1)
    return {'message': 'hello'}

在 docker 中运行

CMD ["uvicorn", "app.main:app", "--proxy-headers", "--host", "0.0.0.0", "--port", "80"]

我进行了以下测试：

ab -c 100 -n 1000 localhost/loadtest

这给了我结果：

bersling-2:cas bersling$ ab -c 100 -n 1000 localhost/loadtest
This is ApacheBench, Version 2.3 <$Revision: 1879490 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed …

这个问题恰逢其时,因为我也在努力优化.我知道R中不同的"正常"优化程序,我知道像雪,降雪,Rmpi等喜欢的并行包.然而,我没有设法在我的计算机上并行运行优化.

一些玩具代码说明:

f <- function(x) sum((x-1:length(x))^2)
a <- 1:5
optim(a,f)
nlm(f,a)

我想要做的是并行化optim()函数(或nlm()函数,它基本相同).我的真实函数f()要复杂得多,一个优化循环持续大约半小时.如果我想运行100个样本的模拟,那个需要很长时间.我想避免为并行计算编写自己的牛顿算法,所以我希望有人能给我一些关于如何在R中使用并行计算来解决复杂优化问题的提示.

我认为这个问题与相关问题的问题不同.我的请求专门针对并行计算,而非一些更快的替代优化.

这些是我在为使用MPI(在C++中)并行运行的算法设计错误处理时遇到的一些常见问题:

• 异常是否在并行执行的代码中工作？是否定义了行为？
• 他们是如何工作的？对于不同的实现,这有何不同？
• 这是好的做法 - 还是应该使用退货代码？

我正在重构我的程序以使用Parallel.ForEach.之前,当我使用常规for循环时,我正在使用Dispatcher更新WPF进度条,通过将当前数组索引除以数组大小来显示%completed.使用并行的foreach循环,这不能正确显示,即%跳跃,这是预期的.

如何为每个循环从并行更新WPF进度条,以便跟踪已完成的迭代次数？

我在大量多维向量上进行分层凝聚聚类,我注意到最大的瓶颈是构造距离矩阵.这项任务的天真实现如下(在Python中):

''' v = an array (N,d), where rows are the observations
and columns the dimensions'''
def create_dist_matrix(v):
   N = v.shape[0]
   D = np.zeros((N,N))
   for i in range(N):
      for j in range(i+1):
          D[i,j] = cosine(v[i,:],v[j,:]) # scipy.spatial.distance.cosine()
   return D

我想知道哪个是为这个例程添加一些并行性的最佳方法.一种简单的方法是中断并将外部循环分配给多个作业,例如,如果您有10个处理器,则为不同的范围创建10个不同的作业i,然后连接结果.然而,这种"横向"解决方案似乎并不合适.是否有任何其他并行算法(或现有库)用于此任务？任何帮助将受到高度赞赏.

据我所知multicore,R版本2.14已被弃用,我被建议开始使用parallel内置于R 3.0基础的软件包.

通过文档parallel,我发现主要有两个函数可以调用parallel,collect例如:

p <- parallel(1:10)
q <- parallel(1:20)
collect(list(p, q)) # wait for jobs to finish and collect all results

由于我不太熟悉并行计算的细节,所以我总是multicore's mclapply在我的代码中使用开箱即用.我想知道如何利用新的parallel包装mclapply.

干杯

最近,我回答了一个关于优化可能的可并行化方法来生成任意基数的每个排列的问题.我发布了类似于Parallelized,糟糕的实现代码块列表的答案,有人几乎立即指出了这一点:

这几乎可以保证为您提供错误的共享,并且可能会慢很多倍.(信用gjvdkamp)

他们是对的,死亡很慢.也就是说,我研究了这个主题,并找到了一些有趣的材料和建议(仅存档的MSDN杂志,.NET Matters:False Sharing)来对抗它.如果我理解正确,当线程访问连续的内存(例如,可能支持该数组的数组ConcurrentStack)时,可能会发生错误共享.

对于横向规则下面的代码,a Bytes是:

struct Bytes {
  public byte A; public byte B; public byte C; public byte D;
  public byte E; public byte F; public byte G; public byte H;
}

对于我自己的测试,我想获得这个运行的并行版本并且真正更快,所以我创建了一个基于原始代码的简单示例.6因为limits[0]是我的一个懒惰的选择-我的电脑有6个核心.

单线程块 平均运行时间:10s0059ms

  var data = new List<Bytes>();
  var limits = new byte[] { 6, 16, 16, 16, 32, 8, 8, 8 };

  for (byte a = 0; …