とにかく私にとっては努力の価値があったので、興味がある人のために、ここで最も難しくてエレガントでない解決策を提案します。私の解決策は、C ++のワンパスアルゴリズムでマルチスレッドのmin-maxを実装し、これを使用してPython拡張モジュールを作成することです。この作業には、PythonおよびNumPy C / C ++ APIの使用方法を学習するための少しのオーバーヘッドが必要です。ここでは、コードを示し、このパスを使用したい人のためにいくつかの簡単な説明と参照を示します。
マルチスレッドの最小/最大
ここにはあまり興味深いものはありません。配列はサイズのチャンクに分割されますlength / workers。最小値/最大値は、の各チャンクについて計算futureされ、グローバル最小値/最大値がスキャンされます。
// mt_np.cc
//
// multi-threaded min/max algorithm
#include <algorithm>
#include <future>
#include <vector>
namespace mt_np {
/*
* Get {min,max} in interval [begin,end)
*/
template <typename T> std::pair<T, T> min_max(T *begin, T *end) {
T min{*begin};
T max{*begin};
while (++begin < end) {
if (*begin < min) {
min = *begin;
continue;
} else if (*begin > max) {
max = *begin;
}
}
return {min, max};
}
/*
* get {min,max} in interval [begin,end) using #workers for concurrency
*/
template <typename T>
std::pair<T, T> min_max_mt(T *begin, T *end, int workers) {
const long int chunk_size = std::max((end - begin) / workers, 1l);
std::vector<std::future<std::pair<T, T>>> min_maxes;
// fire up the workers
while (begin < end) {
T *next = std::min(end, begin + chunk_size);
min_maxes.push_back(std::async(min_max<T>, begin, next));
begin = next;
}
// retrieve the results
auto min_max_it = min_maxes.begin();
auto v{min_max_it->get()};
T min{v.first};
T max{v.second};
while (++min_max_it != min_maxes.end()) {
v = min_max_it->get();
min = std::min(min, v.first);
max = std::max(max, v.second);
}
return {min, max};
}
}; // namespace mt_np
Python拡張モジュール
ここからが醜くなります... PythonでC ++コードを使用する1つの方法は、拡張モジュールを実装することです。このモジュールは、distutils.core標準モジュールを使用して構築およびインストールできます。これに伴うものの完全な説明は、Pythonのドキュメントhttps://docs.python.org/3/extending/extending.htmlでカバーされています。 注：https : //docs.python.org/3/extending/index.html#extending-indexを引用して、同様の結果を得る他の方法は確かにあります：
このガイドでは、このバージョンのCPythonの一部として提供される拡張機能を作成するための基本的なツールのみを扱います。Cython、cffi、SWIG、Numbaなどのサードパーティツールは、Python用のCおよびC ++拡張を作成するためのよりシンプルで洗練されたアプローチを提供します。
基本的に、このルートはおそらく実用的というよりも学術的です。それが言われて、私が次にしたことは、チュートリアルにかなり固執して、モジュールファイルを作成することでした。これは本質的に、distutilsがコードの処理方法を知り、それからPythonモジュールを作成するための定型文です。これを行う前に、システムパッケージを汚染しないようにPython 仮想環境を作成することをお勧めします（https://docs.python.org/3/library/venv.html#module-venvを参照）。
モジュールファイルは次のとおりです。
// mt_np_forpy.cc
//
// C++ module implementation for multi-threaded min/max for np
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#include <python3.6/numpy/arrayobject.h>
#include "mt_np.h"
#include <cstdint>
#include <iostream>
using namespace std;
/*
* check:
* shape
* stride
* data_type
* byteorder
* alignment
*/
static bool check_array(PyArrayObject *arr) {
if (PyArray_NDIM(arr) != 1) {
PyErr_SetString(PyExc_RuntimeError, "Wrong shape, require (1,n)");
return false;
}
if (PyArray_STRIDES(arr)[0] != 8) {
PyErr_SetString(PyExc_RuntimeError, "Expected stride of 8");
return false;
}
PyArray_Descr *descr = PyArray_DESCR(arr);
if (descr->type != NPY_LONGLTR && descr->type != NPY_DOUBLELTR) {
PyErr_SetString(PyExc_RuntimeError, "Wrong type, require l or d");
return false;
}
if (descr->byteorder != '=') {
PyErr_SetString(PyExc_RuntimeError, "Expected native byteorder");
return false;
}
if (descr->alignment != 8) {
cerr << "alignment: " << descr->alignment << endl;
PyErr_SetString(PyExc_RuntimeError, "Require proper alignement");
return false;
}
return true;
}
template <typename T>
static PyObject *mt_np_minmax_dispatch(PyArrayObject *arr) {
npy_intp size = PyArray_SHAPE(arr)[0];
T *begin = (T *)PyArray_DATA(arr);
auto minmax =
mt_np::min_max_mt(begin, begin + size, thread::hardware_concurrency());
return Py_BuildValue("(L,L)", minmax.first, minmax.second);
}
static PyObject *mt_np_minmax(PyObject *self, PyObject *args) {
PyArrayObject *arr;
if (!PyArg_ParseTuple(args, "O", &arr))
return NULL;
if (!check_array(arr))
return NULL;
switch (PyArray_DESCR(arr)->type) {
case NPY_LONGLTR: {
return mt_np_minmax_dispatch<int64_t>(arr);
} break;
case NPY_DOUBLELTR: {
return mt_np_minmax_dispatch<double>(arr);
} break;
default: {
PyErr_SetString(PyExc_RuntimeError, "Unknown error");
return NULL;
}
}
}
static PyObject *get_concurrency(PyObject *self, PyObject *args) {
return Py_BuildValue("I", thread::hardware_concurrency());
}
static PyMethodDef mt_np_Methods[] = {
{"mt_np_minmax", mt_np_minmax, METH_VARARGS, "multi-threaded np min/max"},
{"get_concurrency", get_concurrency, METH_VARARGS,
"retrieve thread::hardware_concurrency()"},
{NULL, NULL, 0, NULL} /* sentinel */
};
static struct PyModuleDef mt_np_module = {PyModuleDef_HEAD_INIT, "mt_np", NULL,
-1, mt_np_Methods};
PyMODINIT_FUNC PyInit_mt_np() { return PyModule_Create(&mt_np_module); }
このファイルでは、PythonとNumPy APIの重要な使用方法があります。詳細については、https：//docs.python.org/3/c-api/arg.html#c.PyArg_ParseTupleおよびNumPyを参照してください。：https : //docs.scipy.org/doc/numpy/reference/c-api.array.html。
モジュールのインストール
次に行うことは、distutilsを利用してモジュールをインストールすることです。これにはセットアップファイルが必要です。
# setup.py
from distutils.core import setup,Extension
module = Extension('mt_np', sources = ['mt_np_module.cc'])
setup (name = 'mt_np',
version = '1.0',
description = 'multi-threaded min/max for np arrays',
ext_modules = [module])
最終的にモジュールをインストールするにpython3 setup.py installは、仮想環境から実行します。
モジュールのテスト
最後に、C ++実装が実際にNumPyの単純な使用よりも優れているかどうかをテストして確認できます。そのために、簡単なテストスクリプトを次に示します。
# timing.py
# compare numpy min/max vs multi-threaded min/max
import numpy as np
import mt_np
import timeit
def normal_min_max(X):
return (np.min(X),np.max(X))
print(mt_np.get_concurrency())
for ssize in np.logspace(3,8,6):
size = int(ssize)
print('********************')
print('sample size:', size)
print('********************')
samples = np.random.normal(0,50,(2,size))
for sample in samples:
print('np:', timeit.timeit('normal_min_max(sample)',
globals=globals(),number=10))
print('mt:', timeit.timeit('mt_np.mt_np_minmax(sample)',
globals=globals(),number=10))
これをすべて実行した結果は次のとおりです。
8
********************
sample size: 1000
********************
np: 0.00012079699808964506
mt: 0.002468645994667895
np: 0.00011947099847020581
mt: 0.0020772050047526136
********************
sample size: 10000
********************
np: 0.00024697799381101504
mt: 0.002037393998762127
np: 0.0002713389985729009
mt: 0.0020942929986631498
********************
sample size: 100000
********************
np: 0.0007130410012905486
mt: 0.0019842900001094677
np: 0.0007540129954577424
mt: 0.0029724110063398257
********************
sample size: 1000000
********************
np: 0.0094779249993735
mt: 0.007134920000680722
np: 0.009129883001151029
mt: 0.012836456997320056
********************
sample size: 10000000
********************
np: 0.09471094200125663
mt: 0.0453535050037317
np: 0.09436299200024223
mt: 0.04188535599678289
********************
sample size: 100000000
********************
np: 0.9537652180006262
mt: 0.3957935369980987
np: 0.9624398809974082
mt: 0.4019058070043684
これらは、スレッドの初期の結果が示す3.5倍のスピードアップとマルチスレッド化を組み込んでいない結果よりもはるかに有望ではありません。私が得た結果はある程度合理的です。スレッド化のオーバーヘッドが予想され、配列が非常に大きくなるまでの時間を支配します。その時点でパフォーマンスの向上はstd::thread::hardware_concurrencyxの増加に近づき始めます。
結論
特にマルチスレッドに関しては、いくつかのNumPyコードに対してアプリケーション固有の最適化の余地は確かにあります。努力する価値があるかどうかは私には明らかではありませんが、確かに良い練習（または何か）のようです。Cythonのような「サードパーティのツール」のいくつかを学ぶことは、時間のより良い使い方かもしれませんが、誰もが知っていると思います。
amaxandと比較するいくつかのテストを実行しますamin