使用Python多处理解决令人尴尬的并行问题

82

如何使用多重处理来解决令人尴尬的并行问题？

令人尴尬的并行问题通常包括三个基本部分：

  1. 读取输入数据（从文件，数据库，tcp连接等）。
  2. 在输入数据上运行计算，其中每个计算独立于任何其他计算。
  3. 将计算结果写入文件，数据库，TCP连接等。

我们可以在两个方面并行化程序：

  • 第2部分可以在多个内核上运行，因为每个计算都是独立的。处理顺序无关紧要。
  • 每个部分可以独立运行。第1部分可以将数据放在输入队列中，第2部分可以将数据从输入队列中拉出并将结果放到输出队列中，第3部分可以将结果从输出队列中拉出并写出。

这似乎是并发编程中最基本的模式，但是我仍然在尝试解决它方面迷失了方向，因此让我们写一个规范的示例来说明如何使用多重处理来完成。

这是示例问题：给定一个以整数行作为输入的CSV文件，计算其总和。将问题分为三个部分，这些部分可以并行运行：

  1. 将输入文件处理为原始数据（整数列表/可迭代数）
  2. 并行计算数据总和
  3. 输出总和

下面是传统的单进程绑定Python程序，它解决了这三个任务：

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# basicsums.py
"""A program that reads integer values from a CSV file and writes out their
sums to another CSV file.
"""

import csv
import optparse
import sys

def make_cli_parser():
    """Make the command line interface parser."""
    usage = "\n\n".join(["python %prog INPUT_CSV OUTPUT_CSV",
            __doc__,
            """
ARGUMENTS:
    INPUT_CSV: an input CSV file with rows of numbers
    OUTPUT_CSV: an output file that will contain the sums\
"""])
    cli_parser = optparse.OptionParser(usage)
    return cli_parser


def parse_input_csv(csvfile):
    """Parses the input CSV and yields tuples with the index of the row
    as the first element, and the integers of the row as the second
    element.

    The index is zero-index based.

    :Parameters:
    - `csvfile`: a `csv.reader` instance

    """
    for i, row in enumerate(csvfile):
        row = [int(entry) for entry in row]
        yield i, row


def sum_rows(rows):
    """Yields a tuple with the index of each input list of integers
    as the first element, and the sum of the list of integers as the
    second element.

    The index is zero-index based.

    :Parameters:
    - `rows`: an iterable of tuples, with the index of the original row
      as the first element, and a list of integers as the second element

    """
    for i, row in rows:
        yield i, sum(row)


def write_results(csvfile, results):
    """Writes a series of results to an outfile, where the first column
    is the index of the original row of data, and the second column is
    the result of the calculation.

    The index is zero-index based.

    :Parameters:
    - `csvfile`: a `csv.writer` instance to which to write results
    - `results`: an iterable of tuples, with the index (zero-based) of
      the original row as the first element, and the calculated result
      from that row as the second element

    """
    for result_row in results:
        csvfile.writerow(result_row)


def main(argv):
    cli_parser = make_cli_parser()
    opts, args = cli_parser.parse_args(argv)
    if len(args) != 2:
        cli_parser.error("Please provide an input file and output file.")
    infile = open(args[0])
    in_csvfile = csv.reader(infile)
    outfile = open(args[1], 'w')
    out_csvfile = csv.writer(outfile)
    # gets an iterable of rows that's not yet evaluated
    input_rows = parse_input_csv(in_csvfile)
    # sends the rows iterable to sum_rows() for results iterable, but
    # still not evaluated
    result_rows = sum_rows(input_rows)
    # finally evaluation takes place as a chain in write_results()
    write_results(out_csvfile, result_rows)
    infile.close()
    outfile.close()


if __name__ == '__main__':
    main(sys.argv[1:])

让我们使用该程序并将其重写以使用多重处理来并行化上面概述的三个部分。下面是这个新的并行化程序的框架，需要对其进行充实以解决注释中的各个部分：

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# multiproc_sums.py
"""A program that reads integer values from a CSV file and writes out their
sums to another CSV file, using multiple processes if desired.
"""

import csv
import multiprocessing
import optparse
import sys

NUM_PROCS = multiprocessing.cpu_count()

def make_cli_parser():
    """Make the command line interface parser."""
    usage = "\n\n".join(["python %prog INPUT_CSV OUTPUT_CSV",
            __doc__,
            """
ARGUMENTS:
    INPUT_CSV: an input CSV file with rows of numbers
    OUTPUT_CSV: an output file that will contain the sums\
"""])
    cli_parser = optparse.OptionParser(usage)
    cli_parser.add_option('-n', '--numprocs', type='int',
            default=NUM_PROCS,
            help="Number of processes to launch [DEFAULT: %default]")
    return cli_parser


def main(argv):
    cli_parser = make_cli_parser()
    opts, args = cli_parser.parse_args(argv)
    if len(args) != 2:
        cli_parser.error("Please provide an input file and output file.")
    infile = open(args[0])
    in_csvfile = csv.reader(infile)
    outfile = open(args[1], 'w')
    out_csvfile = csv.writer(outfile)

    # Parse the input file and add the parsed data to a queue for
    # processing, possibly chunking to decrease communication between
    # processes.

    # Process the parsed data as soon as any (chunks) appear on the
    # queue, using as many processes as allotted by the user
    # (opts.numprocs); place results on a queue for output.
    #
    # Terminate processes when the parser stops putting data in the
    # input queue.

    # Write the results to disk as soon as they appear on the output
    # queue.

    # Ensure all child processes have terminated.

    # Clean up files.
    infile.close()
    outfile.close()


if __name__ == '__main__':
    main(sys.argv[1:])

这些代码以及可以生成示例CSV文件以进行测试的另一段代码可以在github上找到。

对于您的并发专家如何解决此问题，我将不胜感激。

这是我在考虑此问题时遇到的一些问题。解决任何/所有问题的奖励积分：

  • 我应该有子进程来读取数据并将其放入队列中，还是主进程可以做到这一点而不会阻塞，直到读取完所有输入？
  • 同样，我应该有一个子进程从处理后的队列中写出结果，还是主进程可以这样做而不必等待所有结果？
  • 我应该对总和运算使用进程池吗？
  • 假设我们不需要在数据输入时退出输入和输出队列，而是可以等到所有输入都被解析并计算出所有结果之后（例如，因为我们知道所有输入和输出都将适合系统内存）。我们是否应该以任何方式更改算法（例如，不要与I / O同时运行任何进程）？
python  concurrency  multiprocessing  embarrassingly-parallel 
— 获得基因
source
2
哈哈，我很尴尬地喜欢这个词。我很惊讶这是我第一次听到这个词，这是提及该概念的好方法。
— 汤姆·内兰德

Answers:

70

我的解决方案有额外的花哨之处，以确保输出的顺序与输入的顺序相同。我使用multiprocessing.queue在进程之间发送数据，发送停止消息，以便每个进程都知道退出检查队列。我认为资料来源中的评论应该清楚说明发生了什么，但如果没有告知我。

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# multiproc_sums.py
"""A program that reads integer values from a CSV file and writes out their
sums to another CSV file, using multiple processes if desired.
"""

import csv
import multiprocessing
import optparse
import sys

NUM_PROCS = multiprocessing.cpu_count()

def make_cli_parser():
    """Make the command line interface parser."""
    usage = "\n\n".join(["python %prog INPUT_CSV OUTPUT_CSV",
            __doc__,
            """
ARGUMENTS:
    INPUT_CSV: an input CSV file with rows of numbers
    OUTPUT_CSV: an output file that will contain the sums\
"""])
    cli_parser = optparse.OptionParser(usage)
    cli_parser.add_option('-n', '--numprocs', type='int',
            default=NUM_PROCS,
            help="Number of processes to launch [DEFAULT: %default]")
    return cli_parser

class CSVWorker(object):
    def __init__(self, numprocs, infile, outfile):
        self.numprocs = numprocs
        self.infile = open(infile)
        self.outfile = outfile
        self.in_csvfile = csv.reader(self.infile)
        self.inq = multiprocessing.Queue()
        self.outq = multiprocessing.Queue()

        self.pin = multiprocessing.Process(target=self.parse_input_csv, args=())
        self.pout = multiprocessing.Process(target=self.write_output_csv, args=())
        self.ps = [ multiprocessing.Process(target=self.sum_row, args=())
                        for i in range(self.numprocs)]

        self.pin.start()
        self.pout.start()
        for p in self.ps:
            p.start()

        self.pin.join()
        i = 0
        for p in self.ps:
            p.join()
            print "Done", i
            i += 1

        self.pout.join()
        self.infile.close()

    def parse_input_csv(self):
            """Parses the input CSV and yields tuples with the index of the row
            as the first element, and the integers of the row as the second
            element.

            The index is zero-index based.

            The data is then sent over inqueue for the workers to do their
            thing.  At the end the input process sends a 'STOP' message for each
            worker.
            """
            for i, row in enumerate(self.in_csvfile):
                row = [ int(entry) for entry in row ]
                self.inq.put( (i, row) )

            for i in range(self.numprocs):
                self.inq.put("STOP")

    def sum_row(self):
        """
        Workers. Consume inq and produce answers on outq
        """
        tot = 0
        for i, row in iter(self.inq.get, "STOP"):
                self.outq.put( (i, sum(row)) )
        self.outq.put("STOP")

    def write_output_csv(self):
        """
        Open outgoing csv file then start reading outq for answers
        Since I chose to make sure output was synchronized to the input there
        is some extra goodies to do that.

        Obviously your input has the original row number so this is not
        required.
        """
        cur = 0
        stop = 0
        buffer = {}
        # For some reason csv.writer works badly across processes so open/close
        # and use it all in the same process or else you'll have the last
        # several rows missing
        outfile = open(self.outfile, "w")
        self.out_csvfile = csv.writer(outfile)

        #Keep running until we see numprocs STOP messages
        for works in range(self.numprocs):
            for i, val in iter(self.outq.get, "STOP"):
                # verify rows are in order, if not save in buffer
                if i != cur:
                    buffer[i] = val
                else:
                    #if yes are write it out and make sure no waiting rows exist
                    self.out_csvfile.writerow( [i, val] )
                    cur += 1
                    while cur in buffer:
                        self.out_csvfile.writerow([ cur, buffer[cur] ])
                        del buffer[cur]
                        cur += 1

        outfile.close()

def main(argv):
    cli_parser = make_cli_parser()
    opts, args = cli_parser.parse_args(argv)
    if len(args) != 2:
        cli_parser.error("Please provide an input file and output file.")

    c = CSVWorker(opts.numprocs, args[0], args[1])

if __name__ == '__main__':
    main(sys.argv[1:])
— 吧台
source
1
这是实际使用的唯一答案multiprocessing。赏金归您，先生。
— gotgenes 2010年
1
实际上有必要调用join输入和数字处理过程吗？您不能只加入输出过程而忽略其他过程吗？如果是这样，还有充分的理由调用join所有其他进程吗？
— 瑞安·汤普森
“所以线程知道要退出” - “在线程之间发送数据” -线程和进程有很大的不同。我看到这会使新手感到困惑。更重要的是，在已经被广泛支持的答案中使用正确的术语。您正在这里开始新的流程。您不只是在当前进程中生成线程。
— Jan-Philip Gehrcke博士
很公平。我已经修正了文字。
— hbar 2015年
很棒的答案。非常感谢。
— eggonlegs
7

迟到聚会了...

joblib在多重处理之上有一层，以帮助进行并行for循环。除了非常简单的语法外，它还为您提供了诸如延迟分配作业之类的便利，并提供了更好的错误报告。

作为免责声明，我是joblib的原始作者。

— 盖尔·瓦罗夸（Gael Varoquaux）
source
3
那么Joblib是否有能力并行处理I / O，还是您必须手工完成？您可以使用Joblib提供代码示例吗？谢谢！
— Roko Mijic'17年
5

我意识到我参加聚会有点晚了，但是我最近发现了GNU parallel，并想展示用它完成这项典型任务有多么容易。

cat input.csv | parallel ./sum.py --pipe > sums

这样的事情将为sum.py：

#!/usr/bin/python

from sys import argv

if __name__ == '__main__':
    row = argv[-1]
    values = (int(value) for value in row.split(','))
    print row, ':', sum(values)

并行将为sum.py每行input.csv（当然是并行）运行，然后将结果输出到sums。显然比multiprocessing麻烦好

— 博格丹·库里尼奇
source
3
GNU并行文档将为输入文件中的每一行调用一个新的Python解释器。在使用固态驱动器的i7 MacBook Pro上启动新的Python解释器的开销（对于Python 2.7约为30毫秒，对于Python 3.3约为40毫秒）可能大大超过了处理单个数据行并导致浪费了很多时间，收益却比预期的要差。在您的示例问题的情况下，我可能会达到multiprocessing.Pool。
— gotgenes
4

老套。

p1.py

import csv
import pickle
import sys

with open( "someFile", "rb" ) as source:
    rdr = csv.reader( source )
    for line in eumerate( rdr ):
        pickle.dump( line, sys.stdout )

p2.py

import pickle
import sys

while True:
    try:
        i, row = pickle.load( sys.stdin )
    except EOFError:
        break
    pickle.dump( i, sum(row) )

p3.py

import pickle
import sys
while True:
    try:
        i, row = pickle.load( sys.stdin )
    except EOFError:
        break
    print i, row

这是多处理的最终结构。

python p1.py | python p2.py | python p3.py

是的，shell在操作系统级别将它们编织在一起。对我来说似乎更简单，并且效果很好。

是的，使用泡菜（或cPickle）会产生更多开销。但是，简化似乎值得付出努力。

如果您希望文件名作为的参数p1.py，则很容易更改。

更重要的是，如下所示的功能非常方便。

def get_stdin():
    while True:
        try:
            yield pickle.load( sys.stdin )
        except EOFError:
            return

这使您可以执行以下操作：

for item in get_stdin():
     process item

这非常简单，但是并不能轻易让您运行多个P2.py副本。

您有两个问题：扇出和扇入。P1.py必须以某种方式散布到多个P2.py。而且P2.py必须以某种方式将其结果合并为一个P3.py。

老式的扇出方法是“推”式架构，非常有效。

从理论上讲，从公共队列中拉出多个P2.py是资源的最佳分配。这通常是理想的，但是它也是大量的编程。编程真的必要吗？还是循环处理足够好？

实际上，您会发现使P1.py在多个P2.py之间进行简单的“循环”处理可能会很好。您将P1.py配置为通过命名管道处理n个P2.py副本。每个P2.py将从其相应的管道读取。

如果一个P2.py获得了所有“最坏情况”数据并落后了怎么办？是的，轮询不是完美的。但是它比仅一个P2.py更好，并且您可以通过简单的随机化解决这种偏差。

从多个P2.py到一个P3.py的扇入仍然有些复杂。在这一点上，老式的方法不再是有利的。P3.py需要使用该select库从多个命名管道中读取以交错读取。

— 洛特
source
这是不是GET多毛，当我想推出np2.py的情况下，让他们消耗和处理m的数据块r被p1.py行输出，并有p3.py获得mXr从所有的结果np2.py实例？
— gotgenes 2010年
1
我在问题中没有看到该要求。（也许这个问题太长和太复杂，以至于无法使该要求脱颖而出。）重要的是，您应该有充分的理由期望多个p2可以真正解决您的性能问题。尽管我们可以假设可能存在这种情况，但是* nix架构从未有过这种情况，并且没有人适合添加它。拥有多个p2可能会有所帮助。但是在过去的40年中，没有人看到足够的必要使它成为外壳的一流组成部分。
— S.Lott
那是我的错。让我编辑并澄清这一点。为了帮助我改善问题，困惑是否来自使用sum()？这只是出于说明目的。我可以将它替换为do_something()，但是我想要一个具体的，易于理解的示例（请参见第一句话）。实际上，do_something()由于每个调用都是独立的，因此我的CPU占用率很高，但可并行处理。因此，多核这将有所帮助。
— gotgenes 2010年
“混淆是否来自sum（）的使用？” 显然不是。我不确定为什么你会提到它。您说：“当我要启动n个p2.py实例时，这不会变得更毛茸茸了”。我在问题中没有看到该要求。
— S.Lott
0

也有可能在第1部分中引入一些并行性。像CSV这样简单的格式可能不是问题，但是如果输入数据的处理明显比读取数据慢，则可以读取更大的块，然后继续读取直到找到“行分隔符”（在CSV情况下为换行符，但同样取决于读取的格式；如果格式足够复杂，则该行不起作用）。

然后可以将这些块（每个块可能包含多个条目）移植到大量并行进程中，从队列中读取作业，然后对它们进行解析和拆分，然后将其放置在阶段2的队列中。

— 瓦汀
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.