मैं ऑब्जेक्ट ओरिएंटेड और वेक्टर आधारित डिज़ाइन के बीच फटा हुआ हूं। मुझे उन क्षमताओं, संरचना और सुरक्षा से प्यार है जो वस्तुएं पूरी वास्तुकला को देती हैं। लेकिन एक ही समय में, गति मेरे लिए बहुत महत्वपूर्ण है, और एक सरणी में सरल फ्लोट चर होने से वास्तव में वेक्टर आधारित भाषाओं / पुस्तकालयों जैसे कि पाइथन में मैटलैब या सुपीरियर में मदद मिलती है।
यहाँ एक कोड है जिसे मैंने अपनी बात समझाने के लिए लिखा है
समस्या: टो अस्थिरता संख्या जोड़ना। यदि x और y दो अस्थिरता संख्याएँ हैं, तो अस्थिरता का योग है (x ^ 2 + y ^ 2) ^ 0.5 (कुछ गणितीय स्थिति को देखते हुए लेकिन यह यहाँ महत्वपूर्ण नहीं है)।
मैं इस ऑपरेशन को बहुत तेजी से करना चाहता हूं, और साथ ही मुझे यह सुनिश्चित करने की आवश्यकता है कि लोग सिर्फ गलत तरीके (x + y) में अस्थिरता न जोड़ें। ये दोनों ही महत्वपूर्ण हैं।
OO आधारित डिजाइन कुछ इस तरह होगा:
from datetime import datetime
from pandas import *
class Volatility:
def __init__(self,value):
self.value = value
def __str__(self):
return "Volatility: "+ str(self.value)
def __add__(self,other):
return Volatility(pow(self.value*self.value + other.value*other.value, 0.5))
(एक तरफ: उन लोगों के लिए जो पायथन के लिए नए हैं, __add__बस एक फ़ंक्शन है जो +ऑपरेटर को ओवरराइड करता है)
मान लीजिए कि मैं अस्थिरता मूल्यों की टो सूचियाँ जोड़ता हूं
n = 1000000
vs1 = Series(map(lambda x: Volatility(2*x-1.0), range(0,n)))
vs2 = Series(map(lambda x: Volatility(2*x+1.0), range(0,n)))
(एक तरफ: फिर से, पायथन में एक श्रृंखला एक सूचकांक के साथ एक सूची की तरह है) अब मैं दोनों को जोड़ना चाहता हूं:
t1 = datetime.now()
vs3 = vs1 + vs2
t2 = datetime.now()
print t2-t1
बस इसके अलावा मेरी मशीन पर 3.8 सेकंड में चलता है, मैंने जो परिणाम दिए हैं उनमें ऑब्जेक्ट इनिशियलाइज़ेशन समय बिल्कुल भी शामिल नहीं है, इसका एकमात्र जोड़ कोड है जो समयबद्ध किया गया है। यदि मैं एक ही चीज़ को एरपी एरेज़ का उपयोग करके चलाता हूँ:
nv1 = Series(map(lambda x: 2.0*x-1.0, range(0,n)))
nv2 = Series(map(lambda x: 2.0*x+1.0, range(0,n)))
t3 = datetime.now()
nv3 = numpy.sqrt((nv1*nv1+nv2*nv2))
t4 = datetime.now()
print t4-t3
यह 0.03 सेकंड में चलती है। यह 100 गुना से अधिक तेज है!
जैसा कि आप देख सकते हैं, ओओपी तरीका मुझे बहुत सुरक्षा देता है कि लोग अस्थिरता को गलत तरीके से नहीं जोड़ेंगे, लेकिन वेक्टर विधि बस इतनी तेज़ है! क्या कोई डिज़ाइन है जिसमें मैं दोनों प्राप्त कर सकता हूं? मुझे यकीन है कि आप में से बहुत से लोग समान डिजाइन विकल्पों में भाग लेंगे, आपने इसे कैसे काम किया?
यहाँ भाषा का चुनाव सारहीन है। मुझे पता है कि आप में से बहुत से लोग सलाह देंगे कि सी ++ या जावा का उपयोग करें, और कोड वैसे भी वेक्टर आधारित भाषाओं की तुलना में तेजी से चल सकता है। लेकिन वह बात नहीं है। मुझे पायथन का उपयोग करने की आवश्यकता है, क्योंकि मेरे पास अन्य भाषाओं में उपलब्ध पुस्तकालयों की मेजबानी नहीं है। यही मेरी अड़चन है। मुझे इसके भीतर अनुकूलन करने की आवश्यकता है।
और मुझे पता है, कि बहुत सारे लोग समानांतरकरण, gpgpu आदि का सुझाव देंगे, लेकिन मैं पहले एकल कोर प्रदर्शन को अधिकतम करना चाहता हूं, और फिर मैं कोड के दोनों संस्करणों को समानांतर कर सकता हूं।
अग्रिम में धन्यवाद!