Python multiprocessingを使用して、厄介な並列問題を解決する

Question

どのように multiprocessing を使用して 厄介な並列問題 に対処しますか？

厄介な並列問題は、通常3つの基本的な部分で構成されます。

1. Read入力データ（ファイル、データベース、TCP接続などから）。
2. 入力データに対して計算を実行します。各計算は他の計算とは無関係です。
3. Write計算結果（ファイル、データベース、TCP接続など）。

プログラムを2次元で並列化できます。

• 各計算は独立しているため、パート2は複数のコアで実行できます。処理の順序は関係ありません。
• 各パーツは独立して実行できます。パート1はデータを入力キューに入れ、パート2はデータを入力キューから取り出して結果を出力キューに入れ、パート3は結果を出力キューから取り出して書き出すことができます。

これは並行プログラミングの最も基本的なパターンのようですが、それを解決しようとしてもまだ迷っています。マルチプロセッシングを使用してこれがどのように行われるかを説明する正規の例を書いてみましょう。

これが問題の例です：入力として整数の行を含む CSVファイル が与えられた場合、それらの合計を計算します。問題を3つの部分に分けます。これらはすべて並行して実行できます。

1. 入力ファイルを生データ（整数のリスト/反復可能オブジェクト）に処理します。
2. データの合計を並行して計算する
3. 合計を出力する

以下は、これらの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:])

このプログラムを取り上げて、マルチプロセッシングを使用して上記で概説した3つの部分を並列化するように書き換えましょう。以下は、この新しい並列化されたプログラムのスケルトンです。コメント内の部分に対処するために具体化する必要があります。

#!/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にあります です。

並行処理の達人がこの問題にどのように取り組むかについて、ここで何か洞察をいただければ幸いです。

---

この問題について私が考えたときにいくつかの質問がありました。any/allに対処するためのボーナスポイント：

• データを読み込んでキューに入れるための子プロセスを用意する必要がありますか、それともメインプロセスは、すべての入力が読み取られるまでブロックせずにこれを実行できますか？
• 同様に、処理されたキューから結果を書き出すための子プロセスが必要ですか、またはすべての結果を待たずにメインプロセスでこれを実行できますか？
• 合計操作に プロセスプール を使用する必要がありますか？
  • はいの場合、入力プロセスと出力プロセスもブロックせずに、プールでどのメソッドを呼び出して、入力キューに入ってくる結果の処理を開始しますか？ apply_async（） ？ map_async（） ？ imap（） ？ imap_unordered（） ？
• データが入力されたときに入力キューと出力キューを吸い上げる必要はなかったが、すべての入力が解析されてすべての結果が計算されるまで待つことができると想定します（たとえば、すべての入力と出力がシステムメモリに収まることがわかっているため）。アルゴリズムを何らかの方法で変更する必要がありますか（I/Oと同時にプロセスを実行しないなど）？

Answer 1

私の解決策は、出力の順序が入力の順序と同じであることを確認するための追加の口笛を備えています。 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 __== '__main__':
    main(sys.argv[1:])

Answer 2

パーティーに遅刻...

joblib は、並列forループの作成に役立つマルチプロセッシングの上にレイヤーを持っています。非常に単純な構文に加えて、ジョブの遅延ディスパッチやエラー報告の改善などの機能を提供します。

免責事項として、私はjoblibの原作者です。

Answer 3

私はパーティーに少し遅れていることに気づきましたが、最近 GNU parallel を発見しました。この典型的なタスクをそれで簡単に実行できることを示したいと思います。

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

このようなことはsum.pyに対して行われます：

#!/usr/bin/python

from sys import argv

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

Parallelはsum.pyのすべての行に対してinput.csvを実行し（もちろん並列で）、結果をsumsに出力します。 multiprocessing手間よりも明らかに良い

Answer 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

はい、シェルはこれらをOSレベルでまとめました。それは私には簡単に思え、それは非常にうまく機能します。

はい、ピクル（または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の複数のコピーを実行できます。

ファンアウトとファンインの2つの問題があります。 P1.pyは何とかして複数のP2.pyにファンアウトする必要があります。そして、P2.pyは結果を何らかの方法で単一のP3.pyにマージする必要があります。

ファンアウトへの昔ながらのアプローチは「プッシュ」アーキテクチャであり、非常に効果的です。

理論的には、共通のキューからの複数のP2.pyのプルは、リソースの最適な割り当てです。これは多くの場合理想的ですが、かなりの量のプログラミングでもあります。プログラミングは本当に必要ですか？または、ラウンドロビン処理で十分でしょうか？

実際には、P1.pyが複数のP2.py間で処理する単純な「ラウンドロビン」を実行するようにすると、非常に良い場合があります。名前付きパイプを介してP2.pyのnコピーに対処するように構成されたP1.pyがあります。 P2.pyはそれぞれ適切なパイプから読み取ります。

1つのP2.pyがすべての「最悪のケース」のデータを取得し、かなり遅れて実行された場合はどうなりますか？はい、ラウンドロビンは完璧ではありません。しかし、これは1つのP2.pyよりも優れており、単純なランダム化でこのバイアスに対処できます。

複数のP2.pyから1つのP3.pyへのファンインは、まだ少し複雑です。この時点で、旧式のアプローチは有利ではなくなります。 P3.pyは、selectライブラリを使用して複数の名前付きパイプから読み取りをインターリーブする必要があります。

Answer 5

パート1にも少し並列処理を導入することはおそらく可能です。おそらくCSVのように単純な形式の問題ではありませんが、入力データの処理がデータの読み取りよりも著しく遅い場合は、より大きなチャンクを読み取り、「行区切り」が見つかるまで読み取りを続けることができます（ CSVの場合は改行ですが、これも読み取った形式によって異なります。形式が十分に複雑な場合は機能しません）。

これらのチャンクは、おそらく複数のエントリを含んでいる可能性があり、キューからジョブを読み取る並列プロセスの群れにファームされ、そこで解析されて分割され、ステージ2のインキューに配置されます。