相关疑难解决方法(0)

我有一个2d numpy数组X = (xrows, xcols),我想在数组的每个行组合上应用点积,以获得另一个形状的数组P = (xrow, xrow).

代码如下所示:

P = np.zeros((xrow, xrow))
for i in range(xrow):
   for j in range(xrow):
      P[i, j] = numpy.dot(X[i], X[j])

如果阵列X很小但是需要花费大量时间才能很好地工作X.有没有什么方法可以让它更快或更蟒蛇化,以便快速？

Python 多处理池在 Linux 和 Windows 之间具有不同的行为。

当按工人数量运行方法映射时，在 Linux 中，它在您作为参数提供的特定函数的范围内运行进程，但在 Windows 中，每个工人都在父进程的范围内运行，并再次使用不应该使用的代码.

例如：（烧瓶只是为了使它类似于我的代码）

from multiprocessing import Pool, Event
from flask import Flask

print(">>> This code running for every each worker")

app = Flask(__name__)

terminating = None


def f(**kwargs):
    print("f()")
    x = kwargs.pop("x", 1)
    print(x * x)
    return x * x


def worker_warpper(arg):
    func, kwargs = arg
    return func(**kwargs)


def initializer(terminating_):
    global terminating
    terminating = terminating_


@app.route('/check', methods=['GET'])
def check():
    with Pool(processes=3) as pool:
        ls = [(f, {"x": 2}), (f, {"x": 5}), …

我想并行化迭代,其中评估了许多cython实例实例,结果存储在全局numpy数组中:

for cythonInstance in myCythonInstances:
    success = cythonInstance.evaluate(someConstantGlobalVariables,) # very CPU intense
    if success == False:
        break
    globalNumpyArray[instanceSpecificLocation] = cythonInstance.resultVector[:]

实例评估的结果彼此独立.实例之间没有任何类型的交互,除了结果写入相同的全局数组,但是在固定的,预定的和独立的位置.如果一个评估失败,则必须停止迭代.

据我所知,2种可能性是可能的:1)使用多处理包2)制作cython函数并使用prange/openmp.

我根本没有并行化的经验.哪种解决方案更可取,还是有更好的替代方案？谢谢!

我有一个程序，可以将大量文件从一个位置复制到另一个位置-我说的是100,000个以上的文件（此刻我正在按图像顺序复制314g）。它们都位于极端的大型，非常快速的网络存储RAID上。我正在使用shutil顺序复制文件，这需要一些时间，因此我试图找到最佳方法来对此进行优化。我注意到有些软件可以有效地使用多线程从网络中读取文件，从而大大缩短了加载时间，因此我想尝试在python中进行此操作。

我没有编程多线程/多进程的经验-这似乎是正确的领域吗？如果是这样，最好的方法是什么？我看过其他一些关于在python中复制线程文件的SO帖子，它们似乎都说您没有速度提高，但是考虑到我的硬件，我认为情况不会如此。目前，我的IO上限还差得远，资源只占1％左右（我本地有40个内核和64g的RAM）。

• 斯宾塞

说到并行编程，我只接触过多线程，但最近我看到了 mpi，我试图通过在线搜索来了解其中的区别，但无济于事。我认为它们都是为了并行化您的代码的库吗？如果是这样，它们有什么不同？或者它们甚至可以像苹果和橙子一样进行比较。有人可以澄清吗？

我有一段代码需要很长时间才能执行并且占用 CPU 资源。我想多次运行该块，并希望为此充分利用 CPU 的能力。看了一下就asyncio明白了，它主要是为了异步通信，但也是异步任务的通用工具。

在以下示例中，这time.sleep(y)是我要运行的代码的占位符。在此示例中，每个协同例程都依次执行，执行时间约为 8 秒。

import asyncio
import logging
import time


async def _do_compute_intense_stuff(x, y, logger):
    logger.info('Getting it started...')
    for i in range(x):
        time.sleep(y)
    logger.info('Almost done')
    return x * y

logging.basicConfig(format='[%(name)s, %(levelname)s]: %(message)s', level='INFO')
logger = logging.getLogger(__name__)
loop = asyncio.get_event_loop()
co_routines = [
    asyncio.ensure_future(_do_compute_intense_stuff(2, 1, logger.getChild(str(i)))) for i in range(4)]
logger.info('Made the co-routines')
responses = loop.run_until_complete(asyncio.gather(*co_routines))
logger.info('Loop is done')
print(responses)

当我替换time.sleep(y)它时asyncio.sleep(y)，它几乎立即返回。大约await asyncio.sleep(y)需要2秒钟。

有没有办法使用这种方法并行化我的代码，或者我应该使用multiprocessingor threading？我需要将其放入 …

我正在对烧瓶应用程序进行一些单元测试。其中一部分包括为每个测试重新启动烧瓶应用程序。为此，我在setUp()my 的函数中创建 Flask 应用程序unitest.TestCase，以便每次运行时应用程序都处于新鲜状态。另外，我在单独的线程中启动应用程序，以便测试可以在 Flask 应用程序不会阻塞的情况下运行。

下面的例子：

import requests
import unittest
from threading import Thread

class MyTest(unittest.TestCase):

    def setUp(self):
        test_port = 8000
        self.test_url = f"http://0.0.0.0:{str(test_port)}"
        self.app_thread = Thread(target=app.run, kwargs={"host": "0.0.0.0", "port": test_port, "debug": False})
        self.app_thread.start()

    def test_a_test_that_contacts_the_server(self):
        response = requests.post(
            f"{self.test_url}/dosomething",
            json={"foo": "bar"},
            headers=foo_bar
        )
        is_successful = json.loads(response.text)["isSuccessful"]
        self.assertTrue(is_successful, msg=json.loads(response.text)["message"])

    def tearDown(self):
        # what should I do here???
        pass

这会成为问题，因为当初始测试运行后进行的测试时，它们会遇到端口8000使用的问题。这引发了OSError: [Errno 98] Address already in use.

（目前，我已经构建了一个解决方法，在其中生成一个高范围端口列表，以及每个测试使用的另一个端口列表，这样我就不会选择先前测试使用的端口。这个解决方法有效，但我我真的很想知道关闭此烧瓶应用程序的正确方法，最终关闭连接并释放/释放该端口。）

我希望有一种特定的方法可以在函数中关闭此烧瓶应用程序tearDown()。

我应该如何关闭我的tearDown() …

我刚刚在python中阅读了一篇关于GIL(全局解释器锁)的文章.在Python性能方面,这似乎是一个大问题.所以我想知道自己什么是存档更多性能的最佳做法.是线程还是多处理？因为我听到每个人都说不同的东西,所以有一个明确的答案会很高兴.或者至少知道多线程对多处理的优缺点.

亲切的问候,

短剑

我有一个程序正在另一个程序中运行。当子进程运行时，父程序冻结。有没有办法在操作系统中将子进程作为父进程本身运行？

我是 R 新手，但我想在 Rstudio 中使用 TensorFlow 理解和生成快速代码。我理解并行化的概念，但我在理解这些概念之间的差异时遇到了一些问题：并行化、向量化和张量化（对不起，我的英语）。我想要一些简单的例子来理解这些差异。我可以同时应用所有这些概念吗？