यह मेरे लिए वैसे भी प्रयास के लायक था, इसलिए मैं यहां सबसे कठिन और कम से कम सुरुचिपूर्ण समाधान का प्रस्ताव दूंगा जो कोई भी दिलचस्पी ले सकता है। मेरा समाधान C ++ में एक पास एल्गोरिथ्म में एक बहु-थ्रेडेड मिन-मैक्स को लागू करना है, और इसका उपयोग पायथन एक्सटेंशन मॉड्यूल बनाने के लिए किया जाता है। इस प्रयास में अजगर और न्यूमपी सी / सी ++ एपीआई का उपयोग करने के तरीके को सीखने के लिए कुछ ओवरहेड की आवश्यकता होती है, और यहां मैं कोड दिखाऊंगा और जो कोई भी इस पथ से नीचे जाने की इच्छा के लिए कुछ छोटे स्पष्टीकरण और संदर्भ देगा।
बहु थ्रेडेड मिन / मैक्स
यहां कुछ भी दिलचस्प नहीं है। सरणी आकार के टुकड़ों में टूट गई है length / workers। न्यूनतम / अधिकतम की गणना प्रत्येक chunk के लिए की जाती है 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
पायथन एक्सटेंशन मॉड्यूल
यहाँ है जहाँ चीजें बदसूरत होने लगती हैं ... पाइथन में C ++ कोड का उपयोग करने का एक तरीका एक विस्तार मॉड्यूल को लागू करना है। इस मॉड्यूल को distutils.coreमानक मॉड्यूल का उपयोग करके बनाया और स्थापित किया जा सकता है । पाइथन डॉक्यूमेंटेशन में इस बात की पूरी जानकारी दी गई है: https://docs.python.org/3/extending/extend.html । नोट: https://docs.python.org/3/extending/index.html#extending-index पर उद्धृत करने के लिए निश्चित रूप से समान परिणाम प्राप्त करने के अन्य तरीके हैं :
यह मार्गदर्शिका केवल CPython के इस संस्करण के हिस्से के रूप में प्रदान किए गए एक्सटेंशन बनाने के लिए मूल टूल को कवर करती है। तीसरे पक्ष के उपकरण जैसे साइथॉन, सेफी, SWIG और नुम्बा दोनों पायथन के लिए C और C ++ एक्सटेंशन बनाने के लिए सरल और अधिक परिष्कृत दृष्टिकोण दोनों प्रदान करते हैं।
अनिवार्य रूप से, यह मार्ग संभवतः व्यावहारिक से अधिक अकादमिक है। उस के साथ कहा जा रहा है, मैंने आगे क्या किया, ट्यूटोरियल के बहुत करीब चिपके हुए, एक मॉड्यूल फ़ाइल बनाएं। यह अनिवार्य रूप से डिस्टुटिल के लिए बॉयलरप्लेट है यह जानने के लिए कि आपके कोड के साथ क्या करना है और इसमें से पायथन मॉड्यूल बनाएं। इनमें से किसी को करने से पहले शायद एक पायथन वर्चुअल वातावरण बनाना बुद्धिमानी है, ताकि आप अपने सिस्टम पैकेजों को प्रदूषित न करें (देखें 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); }
इस फ़ाइल में अधिक जानकारी के लिए , https://docs.python.org/3/c-api/arg.html#c.PyArg_Parseupuple , और NumPy के लिए पायथन के साथ-साथ NumPy API का भी महत्वपूर्ण उपयोग है। : https://docs.scipy.org/doc/numpy/reference/c-api.array.html ।
मॉड्यूल को स्थापित करना
मॉड्यूल स्थापित करने के लिए डिस्टुटिल्स का उपयोग करने के लिए अगली चीज है। इसके लिए सेटअप फ़ाइल की आवश्यकता होती है:
# 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.5x स्पीडअप के आसपास कहीं संकेत करते हैं, और मल्टी-थ्रेडिंग को शामिल नहीं करते हैं। मेरे द्वारा प्राप्त किए गए परिणाम कुछ हद तक उचित हैं, मैं उम्मीद करूंगा कि थ्रेडिंग का ओवरहेड और उस समय तक हावी रहेगा जब तक कि ऐरे बहुत बड़े नहीं हो जाते, जिस बिंदु पर प्रदर्शन वृद्धि std::thread::hardware_concurrencyएक्स वृद्धि के दृष्टिकोण के लिए शुरू होगी ।
निष्कर्ष
वहाँ कुछ NumPy कोड के लिए आवेदन विशिष्ट अनुकूलन के लिए निश्चित रूप से कमरा है, ऐसा लगता है, विशेष रूप से बहु सूत्रण के संबंध में होगा। प्रयास के लायक है या नहीं यह मेरे लिए स्पष्ट नहीं है, लेकिन यह निश्चित रूप से एक अच्छा व्यायाम (या कुछ) जैसा लगता है। मुझे लगता है कि शायद साइथॉन जैसे कुछ "थर्ड पार्टी टूल्स" सीखना समय का बेहतर उपयोग हो सकता है, लेकिन कौन जानता है।
amaxamin