AI & GPU
Pythonでのパラレル処理: 初心者ガイド

Pythonでのパラレル処理: 初心者ガイド

はじめに

ビッグデータや複雑な計算が必要な今日の時代において、パラレル処理は性能の最適化と実行時間の短縮に不可欠なツールとなっています。パラレル処理とは、マルチコアプロセッサやディストリビューテッドシステムの力を活用して、複数のタスクやプロセスを同時に実行する手法です。Pythonは汎用的で人気のあるプログラミング言語ですが、パラレル処理を実現するためのさまざまなモジュールやライブラリを提供しています。この記事では、パラレル処理の基礎、Pythonの組み込みパラレルモジュール、Pythonでパラレル処理の力を活用するためのさまざまな手法とベストプラクティスについて探っていきます。

パラレル処理の基礎

Pythonでのパラレル処理の詳細に入る前に、いくつかの重要な概念を理解しましょう。

並行性 vs. パラレリズム

並行性とパラレリズムはしばしば同義語として使われますが、それぞれ異なる意味を持っています:

  • 並行性: 並行性とは、システムが複数のタスクやプロセスを同時に実行する能力を指しますが、必ずしも同時刻に実行されるわけではありません。並行タスクは独立して進行し、実行が交互に行われることで同時実行のように見えます。
  • パラレリズム: パラレリズムは、CPUコアやディストリビューテッドマシンなどの複数の処理ユニットで、実際に同時に複数のタスクやプロセスを実行することを指します。パラレルタスクは真に同時に実行され、利用可能なハードウェアリソースを活用します。

パラレリズムの種類

パラレリズムには主に2つの種類があります:

  • データパラレリズム: データパラレリズムは、入力データを複数の処理ユニットに分散し、各データ部分で同じ処理を独立して実行するものです。この種類のパラレリズムは、同じ計算を大量のデータに適用する必要がある場合に有効です。ここは大規模なデータセット、画像処理やマトリックス演算などに適用する必要があります。
  • タスク並列処理: タスク並列処理は、問題を小さな独立したタスクに分割し、それらを同時に実行することができます。各タスクは異なるデータに対して異なる操作を行うことができます。タスク並列処理は、Webスクレイピングや並列テストなど、複数の独立したタスクを同時に実行する必要がある場合に適しています。

Amdahl's Law と並列処理のパフォーマンス

Amdahl's Lawは、プログラムを並列化することで理論的に達成できるスピードアップを説明する基本原理です。これは、プログラムの並列化できない順次部分によってスピードアップが制限されることを示しています。Amdahl's Lawの公式は以下の通りです:

スピードアップ = 1 / (S + P/N)

ここで:

  • Sはプログラムの順次実行部分(並列化不可能)の割合
  • Pはプログラムの並列化可能部分の割合
  • Nは並列処理ユニットの数

Amdahl's Lawは、並列化の恩恵を最大限に引き出すためには、プログラムの順次ボトルネックを特定し、最適化することの重要性を示しています。

並列処理の課題

並列処理には以下のような課題があります:

  • 同期と通信のオーバーヘッド: 複数のプロセスやスレッドが協調して動作する場合、それらの同期と通信が必要になります。ロックやセマフォなどの同期メカニズムは、データの整合性を保ち、レースコンディションを防ぐ役割を果たします。しかし、過度な同期と通信はオーバーヘッドを引き起こし、パフォーマンスに影響を与える可能性があります。
  • 負荷分散: 利用可能な処理ユニットに負荷を均等に分散することが、最適なパフォーマンスを得るために重要です。負荷分散が偏っていると、一部のプロセスやスレッドが待機状態になる一方で、他の処理ユニットが過負荷になり、リソースの利用効率が低下します。
  • デバッグとテスト: 並列プログラムのデバッグとテストは、より複雑になります。

Pythonの並列処理モジュール

Pythonには、並列処理のための組み込みモジュールがいくつか用意されています。それぞれに長所と使用例があります。一般的に使用されるモジュールをいくつか見ていきましょう。

multiprocessing モジュール

multiprocessing モジュールを使うと、Pythonで複数のプロセスを生成できます。利用可能なCPUコアを活用して並列実行することができます。各プロセスは独自のメモリ領域で実行されるため、真の並列性が得られます。

プロセスの作成と管理

新しいプロセスを作成するには、multiprocessing.Process クラスを使用します。以下は例です:

import multiprocessing
 
def worker():
    # ワーカープロセスの名前を表示する
    print(f"ワーカープロセス: {multiprocessing.current_process().name}")
 
if __name__ == "__main__":
    processes = []
    for _ in range(4):
        p = multiprocessing.Process(target=worker)
        processes.append(p)
        p.start()
 
    for p in processes:
        p.join()

この例では、worker 関数を定義し、それを4つのプロセスで実行しています。各プロセスの名前を表示しています。最後に、すべてのプロセスの完了を待っています。

プロセス間通信 (IPC)

プロセス間では、multiprocessing モジュールが提供するさまざまなIPC機構を使ってデータをやり取りできます:

  • パイプ: パイプを使うと、2つのプロセス間で単方向の通信ができます。multiprocessing.Pipe() を使ってパイプを作成し、send() と recv() メソッドでデータを送受信できます。
  • キュー: キューを使うと、プロセス間でスレッドセーフにデータを交換できます。multiprocessing.Queue() を使ってキューを作成し、put() と get() メソッドでデータを追加/取り出せます。
  • 共有メモリ: 共有メモリを使うと、複数のプロセスが同じメモリ領域にアクセスできます。以下は、提供されたマークダウンファイルの日本語翻訳です。コードの部分は翻訳せず、コメントのみ翻訳しています。ファイルの先頭に追加のコメントは付けていません。

multiprocessing.Value() と multiprocessing.Array() を使ってプロセス間でデータを共有する方法について説明します。

以下は、キューを使ったプロセス間通信の例です:

import multiprocessing
 
# ワーカー関数
def worker(queue):
    while True:
        # キューからアイテムを取り出す
        item = queue.get()
        if item is None:
            # Noneを受け取ったら終了
            break
        print(f"Processing item: {item}")
 
if __name__ == "__main__":
    # キューを作成
    queue = multiprocessing.Queue()
    processes = []
    for _ in range(4):
        # ワーカープロセスを作成し、キューを渡す
        p = multiprocessing.Process(target=worker, args=(queue,))
        processes.append(p)
        p.start()
 
    # キューにアイテムを追加
    for item in range(10):
        queue.put(item)
 
    # ワーカープロセスの終了を指示
    for _ in range(4):
        queue.put(None)
 
    # ワーカープロセスの終了を待つ
    for p in processes:
        p.join()

この例では、キューを作成し、ワーカープロセスに渡しています。メインプロセスがキューにアイテムを追加し、ワーカープロセスがアイテムを消費します。Noneを受け取ったら、ワーカープロセスは終了します。

threading モジュール

threading モジュールは、単一のプロセス内でスレッドを作成および管理する方法を提供します。スレッドは同じメモリ空間で並行して実行されるため、効率的な通信とデータ共有が可能です。

スレッドの作成と管理

新しいスレッドを作成するには、threading.Thread クラスを使用します。以下は例です:

import threading
 
# ワーカー関数
def worker():
    print(f"Worker thread: {threading.current_thread().name}")
 
if __name__ == "__main__":
    threads = []
    for _ in range(4):
        # スレッドを作成し、ワーカー関数を実行
        t = threading.Thread(target=worker)
        threads.append(t)
        t.start()
 
    # すべてのスレッドの終了を待つ
    for t in threads:
        t.join()

この例では、4つのスレッドを作成し、worker 関数を実行します。start() メソッドを使ってスレッドを開始し、join() メソッドを使ってすべてのスレッドの終了を待ちます。

同期プリミティブ

複数のスレッドが共有リソースにアクセスする場合、レースコンディションを防ぎ、データの整合性を確保するために同期が必要です。threading モジュールは、.同期プリミティブ:

  • ロック: ロックは共有リソースへの排他的なアクセスを可能にします。threading.Lock()を使ってロックを作成し、acquire()とrelease()メソッドを使ってロックの取得と解放を行います。
  • セマフォ: セマフォは共有リソースへのアクセスを制限された数のスロットで制御します。threading.Semaphore(n)を使ってセマフォを作成し、nは利用可能なスロットの数です。
  • 条件変数: 条件変数は特定の条件が満たされるまでスレッドが待機できるようにします。threading.Condition()を使って条件変数を作成し、wait()、notify()、notify_all()メソッドを使ってスレッドの実行を調整します。

共有変数へのアクセスを同期するためのロックの使用例:

import threading
 
counter = 0
lock = threading.Lock()
 
def worker():
    global counter
    with lock:
        counter += 1
        print(f"スレッド {threading.current_thread().name}: カウンター = {counter}")
 
if __name__ == "__main__":
    threads = []
    for _ in range(4):
        t = threading.Thread(target=worker)
        threads.append(t)
        t.start()
 
    for t in threads:
        t.join()

この例では、ロックを使ってカウンター変数への排他的なアクセスを保証し、レースコンディションを防いでいます。

concurrent.futures モジュール

concurrent.futuresモジュールは非同期実行と並列処理のための高水準のインターフェースを提供します。スレッドやプロセスの管理の低レベルの詳細を抽象化し、並列コードの記述を容易にします。

ThreadPoolExecutorとProcessPoolExecutor

concurrent.futuresモジュールは2つのエグゼキュータークラスを提供しています:

  • ThreadPoolExecutor: 単一のプロセス内で並行してタスクを実行するワーカースレッドのプールを管理します。
  • ProcessPoolExecutor: 複数のCPUコアを利用して並列にタスクを実行するワーカープロセスのプールを管理します。

ThreadPoolExecutorの使用例は以下の通りです。以下は、提供されたマークダウンファイルの日本語翻訳です。コードの部分は翻訳していません。コメントのみ翻訳しています。

import concurrent.futures
 
def worker(n):
    print(f"Worker {n}: 開始")
    # 作業を実行する
    print(f"Worker {n}: 完了")
 
if __name__ == "__main__":
    with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
        futures = []
        for i in range(8):
            future = executor.submit(worker, i)
            futures.append(future)
 
        for future in concurrent.futures.as_completed(futures):
            future.result()

この例では、最大4つのワーカースレッドを持つ ThreadPoolExecutor を作成しています。 submit() メソッドを使って8つのタスクをエグゼキューターに送信し、非同期実行を表す Future オブジェクトを取得しています。 その後、 as_completed() メソッドを使ってタスクの完了を待ち、 result() メソッドを使って結果を取得しています。

Future オブジェクトと非同期実行

concurrent.futures モジュールは、非同期タスクの実行を表す Future オブジェクトを使用しています。 Future オブジェクトはコンピューテーションの状態と結果をカプセル化しています。 done() メソッドを使ってタスクの完了を確認し、 result() メソッドを使って結果を取得し、 cancel() メソッドを使ってタスクの実行をキャンセルできます。

以下は、 Future オブジェクトを使って非同期実行を処理する例です:

import concurrent.futures
import time
 
def worker(n):
    time.sleep(n)
    return n * n
 
if __name__ == "__main__":
    with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
        futures = [executor.submit(worker, i) for i in range(4)]
 
        for future in concurrent.futures.as_completed(futures):
            result = future.result()
            print(f"Result: {result}")

この例では、4つのタスクをエグゼキューターに送信し、 as_completed() メソッドを使ってタスクの完了を待ちます。各タスクは指定された時間だけ待機し、入力数の二乗を返します。## Python における並列処理テクニック Pythonには、さまざまなユースケースや要件に対応するための並列処理のテクニックやライブラリが用意されています。これらのテクニックを見ていきましょう。

multiprocessing.Pool を使った並列ループ

multiprocessing.Pool クラスを使うと、複数の入力値に対して関数を並列に実行することができます。入力データをワーカープロセスのプールに分散し、結果を収集します。以下に例を示します。

import multiprocessing
 
def worker(n):
    # この関数は入力値 n を二乗して返します
    return n * n
 
if __name__ == "__main__":
    with multiprocessing.Pool(processes=4) as pool:
        results = pool.map(worker, range(10))
        print(results)

この例では、4つのワーカープロセスからなるプールを作成し、map() メソッドを使って 0 から 9 までの数値に対して worker 関数を並列に適用しています。結果は収集され、出力されます。

並列 Map と Reduce 操作

Pythonの multiprocessing モジュールには、Pool.map() と Pool.reduce() メソッドが用意されており、これらを使って並列に map と reduce 操作を行うことができます。これらのメソッドは入力データをワーカープロセスに分散し、結果を収集します。

  • Pool.map(func, iterable): iterable の各要素に func 関数を並列に適用し、結果のリストを返します。
  • Pool.reduce(func, iterable): iterable の要素に対して func 関数を累積的に適用し、単一の値に縮小します。

以下に Pool.map() と Pool.reduce() の使用例を示します:

import multiprocessing
 
def square(x):
    # この関数は入力値 x を二乗して返します
    return x * x
 
def sum_squares(a, b):
    # この関数は二つの値 a と b の和を返します
    return a + b
 
if __name__ == "__main__":
    with multiprocessing.Pool(processes=4) as pool:
        numbers = range(10)
        squared = pool.map(square, numbers)
        result = pool.reduce(sum_squares, squared)
        print(f"Sum of squares: {result}")

この例では、Pool.map() を使って数値を並列に二乗し、その結果を Pool.reduce() で合計しています。### Asynchro

Asynchro

Python の asyncio モジュールは、コルーチンとイベントループを使用した非同期 I/O と並行実行をサポートしています。これにより、複数の I/O 待ち時間の長いタスクを効率的に処理できるようになります。

以下は、asyncio を使用して非同期 HTTP リクエストを行う例です:

import asyncio
import aiohttp
 
async def fetch(url):
    # URL からデータを取得する非同期関数
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()
 
async def main():
    # 複数の URL からデータを取得する非同期関数
    urls = [
        "https://api.example.com/data1",
        "https://api.example.com/data2",
        "https://api.example.com/data3",
    ]
    tasks = []
    for url in urls:
        task = asyncio.create_task(fetch(url))
        tasks.append(task)
 
    results = await asyncio.gather(*tasks)
    for result in results:
        print(result)
 
if __name__ == "__main__":
    asyncio.run(main())

この例では、fetch() 関数が非同期 HTTP GET リクエストを行います。main() 関数では、複数のタスクを作成し、asyncio.gather() を使用して並行して実行します。最後に、結果を表示しています。

分散コンピューティング with mpi4py and dask

分散メモリシステムにわたる並列実行には、Python の mpi4py や dask などのライブラリを使用できます。

  • mpi4py: メッセージ通信インターフェース (MPI) 標準のバインディングを提供し、分散メモリシステムにわたる並列実行を可能にします。
  • dask: 柔軟な並列コンピューティングライブラリで、タスクスケジューリング、分散データ構造、NumPy や Pandas などの他のライブラリとの統合をサポートしています。

以下は、mpi4py を使用した分散コンピューティングの簡単な例です:

from mpi4py import MPI
 
def main():
    # MPI 通信オブジェクトを取得する
    comm = MPI.COMM_WORLD
    rank = comm.Get_rank()
    size = comm.Get_size()
 
    if rank == 0:
        # プロセス 0 が data を作成する
        data = [i for i in range(size)]
    else:
        # その他のプロセスは data を受け取る
        data = None
 
    # データを各プロセスに配布する
    data = comm.bcast(data, root=0)
 
    # 各プロセスでデータを処理する
    result = sum(data)
 
    # 結果を集約する
    total = comm.reduce(result, op=MPI.SUM, root=0)
 
    if rank == 0:
        print(f"Total: {total}")
 
if __name__ == "__main__":
    main()
```以下は、提供されたマークダウンファイルの日本語翻訳です。コードの部分は翻訳せず、コメントのみ翻訳しています。ファイルの先頭に追加のコメントは付けていません。
 
lse:
        data = None
 
    data = comm.scatter(data, root=0)
    # データをすべてのプロセスに分散する
    result = data * data
    # 受け取ったデータの二乗を計算する
 
    result = comm.gather(result, root=0)
    # 結果をルートプロセスに集める
 
    if rank == 0:
        # ルートプロセスの場合
        print(f"Result: {result}")
 
if __name__ == "__main__":
    main()
 
この例では、`MPI.COMM_WORLD`を使ってすべてのプロセスのコミュニケーターを作成しています。ルートプロセス(ランク0)は`comm.scatter()`を使ってデータをすべてのプロセスに分散します。各プロセスは受け取ったデータの二乗を計算します。最後に、結果はルートプロセスに`comm.gather()`で集められます。
 
### `numba`と`cupy`によるGPUアクセラレーション
計算集約的なタスクでは、GPUの力を活用することで並列処理のスピードを大幅に向上させることができます。Pythonライブラリの`numba`と`cupy`はGPUアクセラレーションをサポートしています。
 
- `numba`: Pythonコードのジャストインタイム(JIT)コンパイラを提供し、CPUやGPUに最適化されたネイティブマシンコードにPythonの関数をコンパイルできます。
- `cupy`: NumPy互換のGPU加速計算ライブラリで、広範な数学関数や配列演算をサポートしています。
 
GPUを使ってnumerical computationを高速化する例は以下の通りです:
 
```python
import numba
import numpy as np
 
@numba.jit(nopython=True, parallel=True)
def sum_squares(arr):
    # 配列の各要素の二乗和を計算する
    result = 0
    for i in numba.prange(arr.shape[0]):
        result += arr[i] * arr[i]
    return result
 
arr = np.random.rand(10000000)
result = sum_squares(arr)
print(f"Sum of squares: {result}")

この例では、@numba.jitデコレータを使ってGPU上で並列実行できるようにsum_squares()関数をコンパイルしています。parallel=True引数により自動並列化が有効になります。大量のランダムな数値配列を生成し、GPU加速関数を使って二乗和を計算しています。

ベストプラクティスとヒント

Pythonの並列処理を行う際は、以下のベストプラクティスとヒントを参考にしてください:

並列化可能なタスクの特定

  • 独立して実行できるタスクを見つける
  • 大量のデータ処理や計算集約的なタスクが適している依存関係を最小限に抑える
  • CPUバウンドのタスクで並列実行の恩恵を受けられるものに焦点を当てる。
  • データパラリズムを検討する。同じ操作を異なるデータサブセットに対して実行するタスクに適している。

通信とシンクロナイゼーションのオーバーヘッドを最小限に抑える

  • プロセスやスレッド間で転送するデータ量を最小限に抑え、通信オーバーヘッドを減らす。
  • ロック、セマフォ、条件変数などの適切な同期プリミティブを慎重に使用し、過度の同期を避ける。
  • プロセス間通信にはメッセージパッシングやシェアードメモリを検討する。

並列プロセス/スレッド間でのロードバランシング

  • 利用可能なプロセスやスレッド間で作業負荷を均等に分散し、リソースの活用を最大化する。
  • ワークスティーリングやタスクキューなどの動的ロードバランシング手法を使用し、偏った作業負荷に対応する。
  • タスクの粒度を考慮し、利用可能なリソースに応じてプロセスやスレッドの数を調整する。

レースコンディションとデッドロックの回避

  • 共有リソースへのアクセスの際に、レースコンディションを防ぐために同期プリミティブを正しく使用する。
  • ロックの使用に注意し、デッドロックを引き起こすような循環依存関係を避ける。
  • concurrent.futuresやmultiprocessing.Poolなどの高レベルの抽象化を使用し、自動的に同期を管理する。

並列コードのデバッグとプロファイリング

  • ログやprint文を使用して実行フローを追跡し、問題を特定する。
  • pdbやIDE debuggerなど、並列デバッグをサポートするPythonのデバッグツールを活用する。
  • cProfileやline_profilerなどのツールを使用して、パフォーマンスボトルネックを特定する。

並列処理を使うべき場合と避けるべき場合

  • CPUバウンドのタスクで並列実行の恩恵を受けられる場合に並列処理を使う。
  • I/Oバウンドのタスクや通信オーバーヘードの大きいタスクには並列処理を避ける。
  • 並列プロセスやスレッドの起動と管理のオーバーヘッドを考慮する。並列処理は.以下は、提供されたマークダウンファイルの日本語翻訳です。コードについては、コメントのみ翻訳しています。ファイルの先頭に追加のコメントは付けていません。

実世界での応用

並列処理は、さまざまな分野で応用されています。

科学計算とシミュレーション

  • 並列処理は、科学的なシミュレーション、数値計算、モデリングで広く使用されています。
  • 例には、気象予報、分子動力学シミュレーション、有限要素解析などがあります。

データ処理とアナリティクス

  • 並列処理により、大規模なデータセットの処理が高速化され、データ分析タスクが加速されます。
  • Apache Spark やHadoopなどの大規模データ処理フレームワークで一般的に使用されています。

機械学習と深層学習

  • 並列処理は、大規模な機械学習モデルや深層ニューラルネットワークの学習を加速するのに不可欠です。
  • TensorFlowやPyTorchなどのフレームワークでは、CPUやGPUの並列処理を活用しています。

Webスクレイピングとクロール

  • 並列処理を使うことで、Webページの取得や抽出作業を高速化できます。
  • 複数のプロセスやスレッドにワークロードを分散することで、Webスクレイピングとクロールのスピードが向上します。

並列テストと自動化

  • 並列処理を使うことで、複数のテストケースや シナリオを同時に実行でき、全体的なテスト時間を短縮できます。
  • 大規模なテストスイートや継続的インテグレーションパイプラインで特に有効です。

今後の動向と進歩

Pythonの並列処理分野では、新しいフレームワーク、ライブラリ、ハードウェアの進歩が続いています。今後の動向と進歩には以下のようなものがあります。

新興の並列処理フレームワークとライブラリ

  • 並列プログラミングを簡素化し、パフォーマンスを向上させる新しい並列処理フレームワークやライブラリが開発されています。
  • Ray、Dask、Joblikなどが例で、高レベルの抽象化と分散コンピューティング機能を提供しています。

ヘテロジニアスコンピューティングとアクセラレータ

  • 並列処理の高速化には、ヘテロジニアスなコンピューティング環境とアクセラレータの活用が重要です。ヘテロジニアス・コンピューティングは、CPUやGPU、FPGAなどの異なるタイプのプロセッサを活用し、特定のタスクを高速化することを指します。

  • CuPy、Numba、PyOpenCLなどのPythonライブラリは、アクセラレータとの seamless な統合を可能にし、並列処理を実現します。

量子コンピューティングとその並列処理への潜在的な影響

  • 量子コンピューティングは、特定の計算問題に対して指数関数的な高速化を約束します。
  • Qiskit やCirqなどのPythonライブラリは、量子回路シミュレーションや量子アルゴリズム開発のためのツールを提供します。
  • 量子コンピューティングの進歩に伴い、並列処理が革新され、複雑な問題をより効率的に解決できるようになるかもしれません。

クラウドおよびサーバーレス・コンピューティングにおける並列処理

  • AWSやGCP、Microsoftのクラウドプラットフォームは、サービスを通じて並列処理機能を提供しています。
  • AWS LambdaやGoogle Cloud Functionsなどのサーバーレスコンピューティングプラットフォームでは、インフラストラクチャの管理なしに並列タスクを実行できます。
  • Pythonのライブラリやフレームワークは、クラウドおよびサーバーレスコンピューティングの力を活用した並列処理に適応しつつあります。

結論

Pythonにおける並列処理は、パフォーマンスの最適化と計算集約的なタスクの解決に不可欠なツールとなっています。Pythonの組み込みモジュールであるmultiprocessing、threading、concurrent.futuresを活用することで、開発者は並列実行の力を活用し、ワークロードを複数のプロセスやスレッドに分散できます。

Pythonはまた、さまざまなドメインやユースケースに対応した並列処理のためのライブラリやフレームワークを豊富に提供しています。asyncioによる非同期I/O、mpi4pyやdaskによる分散コンピューティングなど、Pythonには並列処理のための幅広いオプションがあります。

Pythonで並列処理を効果的に活用するには、並列化可能なタスクの特定、通信と同期の最小化など、ベストプラクティスに従うことが重要です。並列処理は、科学計算、データ処理、機械学習、Webスクレイピング、並列テストなど、さまざまな分野で応用されています。データの量と複雑さが増大するにつれ、大規模な計算を処理し、データ集約型のタスクを高速化するために、並列処理が益々重要になってきています。

将来的には、新しいフレームワークの登場、ヘテロジニアス・コンピューティングの進歩、量子コンピューティングの可能性など、Pythonにおける並列処理の未来は非常に魅力的です。クラウドやサーバーレスコンピューティングプラットフォームとの統合により、スケーラブルで効率的な並列実行の可能性がさらに広がっていくことでしょう。

Google TPU: A Beginner's WalkthroughPyTorchでの複数GPUトレーニング