小编tim*_*day的帖子

在我的64位Debian/Lenny系统(4GByte RAM + 4GByte交换分区)上,我可以成功地做到:

v=array(10000*random([512,512,512]),dtype=np.int16)
f=fftn(v)

但是f是一个np.complex128内存消耗是令人震惊的,我不能做更多的结果(例如调制系数然后f=ifftn(f))没有MemoryError回溯.

而不是安装更多的RAM和/或扩展我的交换分区,有没有办法控制scipy/numpy"默认精度"并让它计算一个complex64数组呢？

我知道我可以随后减少它f=array(f,dtype=np.complex64); 我希望它实际上以32位精度和一半内存进行FFT工作.

这有效:

gst-launch-0.10 \
videotestsrc ! ffmpegcolorspace ! 'video/x-raw-yuv' ! mux. \
audiotestsrc ! audioconvert ! 'audio/x-raw-int,rate=44100,channels=1' ! mux. \
avimux name=mux ! filesink location=gst.avi

我可以让它运行一段时间,杀死它,然后totem gst.avi显示一个带有音调的漂亮的测试卡.

但是,尝试做一些更有用的事情

gst-launch-0.10 \
filesrc location=MVI_2034.AVI ! decodebin name=dec \
dec. ! ffmpegcolorspace ! 'video/x-raw-yuv' ! mux. \
dec. ! audioconvert ! 'audio/x-raw-int,rate=44100,channels=1' ! mux. \
avimux name=mux ! filesink location=gst.avi

它只是显示

Setting pipeline to PAUSED ...
Pipeline is PREROLLING ...

然后无限期地停止.

使用decodebin滚动版本的诀窍是什么？

我要声明几个类型的(内部的类的模板上K,并V和提供了一些缓存行为):

typedef std::map<
  long long,
  typename key_to_value_type::iterator  // Ooops... not declared yet
> timestamp_to_key_type;

typedef std::map<
  K,
  std::pair<V,typename timestamp_to_key_type::iterator> 
> key_to_value_type;

当然,由于循环定义,这是不可能的.我可以用它来破解它void*,但我想知道是否有一些前向声明魔法或其他技术可以更好地完成工作.

(是的,我知道boost::bimap有人会回避这个问题).

这个(非常简化的例子)工作正常(Python 2.6.6,Debian Squeeze):

from multiprocessing import Pool
import numpy as np

src=None

def process(row):
    return np.sum(src[row])

def main():
    global src
    src=np.ones((100,100))

    pool=Pool(processes=16)
    rows=pool.map(process,range(100))
    print rows

if __name__ == "__main__":
    main()

然而,经过多年的教育,全球状态不好!!! ,我所有的直觉告诉我,我真的宁愿写更接近的东西:

from multiprocessing import Pool
import numpy as np

def main():
    src=np.ones((100,100))

    def process(row):
        return np.sum(src[row])

    pool=Pool(processes=16)
    rows=pool.map(process,range(100))
    print rows

if __name__ == "__main__":
    main()

但当然这不起作用(挂起无法腌制的东西).

这里的例子是微不足道的,但是当你添加多个"进程"函数时,每个函数都依赖于多个额外的输入......这一切都让人想起30年前用BASIC编写的东西.尝试使用类来至少使用适当的函数聚合状态似乎是一个明显的解决方案,但在实践中似乎并不那么容易.

是否有一些推荐的模式或样式使用multiprocessing.pool,这将避免全局状态的扩散,以支持我想并行映射的每个函数？

经验丰富的"多处理专业人员"如何处理这个问题？

更新:请注意,我实际上对处理更大的数组感兴趣,因此上面的src每个调用/迭代的变化都不如将其分配到池的工作进程中.

我有一个O(N)NxN的集合scipy.sparse.csr_matrix,每个稀疏矩阵都有N个元素集的顺序.我想将所有这些矩阵一起添加到一个常规的NxN numpy数组中.(N大约为1000).矩阵内的非零元素的排列使得得到的和肯定不稀疏(事实上实际上没有留下零元素).

目前我正在做

reduce(lambda x,y: x+y,[m.toarray() for m in my_sparse_matrices])

哪个有效但有点慢:当然,在那里进行的零点无意义处理绝对是可怕的.

有没有更好的办法 ？在文档中我没有什么明显的东西.

更新:根据user545424的建议,我尝试了对稀疏矩阵求和的替代方案,并将稀疏矩阵求和到密集矩阵上.下面的代码显示了在可比时间内运行的所有方法(在四核i7上的amd64 Debian/Squeeze上的Python 2.6.6)

import numpy as np
import numpy.random
import scipy
import scipy.sparse
import time

N=768
S=768
D=3

def mkrandomsparse():
    m=np.zeros((S,S),dtype=np.float32)
    r=np.random.random_integers(0,S-1,D*S)
    c=np.random.random_integers(0,S-1,D*S)
    for e in zip(r,c):
        m[e[0],e[1]]=1.0
    return scipy.sparse.csr_matrix(m)

M=[mkrandomsparse() for i in xrange(N)]

def plus_dense():
    return reduce(lambda x,y: x+y,[m.toarray() for m in M])

def plus_sparse():
    return reduce(lambda x,y: x+y,M).toarray()

def sum_dense():
    return sum([m.toarray() for m in M])

def sum_sparse():
    return …

如果我使用 启动一些用于异步执行的函数QtConcurrent::run，并使用 a 监视返回的 future QFutureWatcher，那么如果我可以在该异步执行函数中执行一些操作来传达一些进度文本，这将导致触发QFutureWatcher其progressTextChanged信号，该怎么办？

即我想做的是这样的：

void fn() {
  ???->setProgressText("Starting);
  ...
  ???->setProgressText("halfway");
  ...
  ???->setProgressText("done!");
}

QFutureWatcher watcher;
connect(&watcher, SIGNAL(progressTextChanged(const QString&)), &someGuiThing, SLOT(updateProgress(const QString&)));
connect(&watcher, SIGNAL(finished(), &someGuiThing, SLOT(doStuff()));
QFuture<void> future=QConcurrent::run(fn);
watcher.setFuture(future);

然而，大问题是，QtConcurrent::run文档明确指出

请注意，QtConcurrent::run() 返回的 QFuture 不支持 取消、暂停或进度报告。返回的QFuture只能用于查询函数的运行/完成状态和返回值。

那么，我能做的最简单的事情是什么，它能让我得到与上面试图做的功能相同的东西呢？我必须放弃吗QtConcurrent::run？QFuture？两个都？（然后返回QThread并排队连接？）

我一直在玩pygame(在Debian/Lenny上).它似乎工作得很好,除了烦人的blits撕裂(全屏或窗口模式).

我正在使用默认的SDL X11驱动程序.谷歌搜索表明SDL的一个已知问题是X11没有提供vsync功能(即使使用FULLSCREEN|DOUBLEBUF|HWSURFACE标志创建的显示),我应该使用"dga"驱动程序.

但是,跑步

SDL_VIDEODRIVER=dga ./mygame.py

抛出pygame初始化

pygame.error: No available video device

(尽管xdpyinfo存在XFree86-DGA扩展).

所以:获得无泪vsynced翻转的诀窍是什么？通过让这个dga工作或其他机制？

我有一个较大的3D numpy标量值数组(如果必须,可以称之为"音量").我想在一系列不规则的,而不是所有已知的前置非整数xyz坐标上插入一个平滑的标量场.

现在,Scipy对此的支持非常好:我使用了过滤音量

filtered_volume = scipy.ndimage.interpolation.spline_filter(volume)

并调用

scipy.ndimage.interpolation.map_coordinates(
    filtered_volume,
    [[z],[y],[x]],
    prefilter=False)

对于感兴趣的(x,y,z),获得表面上很好的(平滑等)插值.

到现在为止还挺好.但是,我的应用程序还需要插值字段的局部导数.目前我通过中心差分获得这些:我还在6个额外点处对体积进行采样(这至少可以通过一次调用完成map_coordinates)并计算例如来自的x导数(i(x+h,y,z)-i(x-h,y,z))/(2*h).(是的,我知道我可以将额外的水龙头数量减少到3并做出"单侧"差异,但不对称会让我烦恼.)

我的直觉是应该有一个更直接的方法来获得渐变,但我不知道足够的样条数学(还)来弄明白,或者了解Scipy实现的内容:scipy/scipy/ndimage/src/ni_interpolation.c.

有没有比中央差分"更直接"获得渐变的更好方法？优选地,允许使用现有功能获得它们而不是攻击Scipy的内部.

由英特尔编译器使用OpenMP的支持的环境变量KMP_BLOCKTIME(文档),我相信控制忙着等待(spinlocked)时间的线程将花费在等待新的工作(链接的文档声称此默认为200毫秒).

GNU编译器使用OpenMP的支持的环境变量GOMP_SPINCOUNT(文档),我相信也控制该库的等效实现细节(虽然表面上表现为一个迭代次数,而不是时间).

我的问题是:Microsoft提供哪些控件(如果有的话)来控制Microsoft编译器使用的OpenMP中的这个参数？ (目前我感兴趣的是VS2010.)

(我,如果我的程序的并行性是完全基于的OpenMP会有什么理由担心这一点,但我的兴趣是通过从大型复杂系统,这也使得显著利用TBB的一些痕迹VTUNE挑起心知肚明.)

Project Euler问题中一个并不罕见的模式似乎相当于:

Stream.from(1).map(f).takeWhile((_>0)).foldLeft(0L)(_+_)

其中f是一些昂贵的计算函数,它将正值返回到某个未知点,然后返回零.

我喜欢并行化的东西,特别是当Scala的并行集合并且.par让它变得如此简单时.但是在没有ParStream的情况下,我提出的最好的是:

val BATCH=1024
Stream.from(1,BATCH).flatMap(
  i=>(i until i+BATCH).par.map(f)
).takeWhile((_>0)).foldLeft(0L)(_+_)

它看起来不是很优雅,而且对BATCH价值的选择很敏感(但是我的四核可以提高x4的速度).

有关更清洁的方法获得相同结果的任何建议吗？