numpy cython

Question

का उपयोग कर dtype एक कस्टम बनाने के लिए कैसे

सी here का उपयोग कर कस्टम numpy dtypes बनाने के लिए उदाहरण हैं

ऐसा लगता है कि यह भी होना चाहिए साइथन का उपयोग करके एक प्रकार का प्रकार बनाने के लिए संभव है (और फिर इसके लिए कस्टम ufuncs बनाएँ)। क्या यह संभव है? यदि हां, तो क्या आप एक उदाहरण पोस्ट कर सकते हैं?

उपयोग के मामले:

मैं कुछ अस्तित्व विश्लेषण करना चाहते हैं। बुनियादी डेटा तत्व संबंधित सेंसर मूल्यों के साथ उत्तरजीविता के समय (फ्लोट) होते हैं (झूठी अगर संबंधित समय विफलता समय का प्रतिनिधित्व करता है और सही है तो यह एक सेंसरिंग समय का प्रतिनिधित्व करता है (यानी, अवलोकन की अवधि के दौरान कोई विफलता नहीं हुई))।

स्पष्ट रूप से मैं इन मानों को संग्रहीत करने के लिए केवल दो numpy arrays का उपयोग कर सकता हूं: समय के लिए एक फ्लोट सरणी और सेंसर मूल्यों के लिए एक बूल सरणी। हालांकि, मैं कई बार होने वाली घटना की संभावना के लिए जिम्मेदार होना चाहता हूं (यह दिल का दौरा करने के लिए एक अच्छा मॉडल है - आप एक से अधिक हो सकते हैं)। इस मामले में, मुझे वस्तुओं की एक सरणी की आवश्यकता है जिसे मैं MultiEvent एस कहता हूं। प्रत्येक MultiEvent में फ्लोट्स (बिना सेंसर विफलता समय) और एक अवलोकन अवधि (एक फ्लोट) का अनुक्रम होता है। ध्यान दें कि असफलताओं की संख्या सभी MultiEvent एस के लिए समान नहीं है। प्रत्येक

के लिए विफलताओं की संख्या

1. जाओ सेंसर समय मिलता है (कि की अवधि है:

   मैं MultiEvent रों की एक सरणी पर कुछ कार्रवाई करने में सक्षम होना चाहिए अवलोकन कम से कम सभी विफलता समयों का योग)

2. पैरामीटर के अतिरिक्त सरणी (जैसे खतरे के मूल्यों की सरणी) के आधार पर लॉग संभावना की गणना करें। उदाहरण के लिए, एक भी MultiEventM और निरंतर खतरा मूल्य h के लिए लॉग संभावना की तरह कुछ होगा: विफलता समय की

   sum(log(h) + h*t for t in M.times) - h*(M.period - sum(M.times))

जहां M.times सूची है (सरणी, जो कुछ भी) और M.period है कुल अवलोकन अवधि। मैं उचित numpy प्रसारण नियमों को लागू करना चाहते हैं, ताकि मैं कर सकते हैं:

log_lik = logp(M_vec,h_vec) 

और यह रूप में लंबे समय M_vec और h_vec के आयाम के रूप में संगत कर रहे हैं काम करेंगे।

मेरा वर्तमान कार्यान्वयन numpy.vectorize का उपयोग करता है। यह 1 और 2 के लिए काफी अच्छा काम करता है, लेकिन यह 3 के लिए बहुत धीमा है। ध्यान दें कि मैं this नहीं कर सकता क्योंकि मेरे मल्टीडाटा ऑब्जेक्ट्स में विफलताओं की संख्या समय से पहले ज्ञात नहीं है।

Answer 1

मैं सीधे सवाल का जवाब नहीं देने के लिए क्षमा चाहता हूं, लेकिन मुझे पहले भी ऐसी ही समस्याएं आई हैं, और यदि मैं सही ढंग से समझता हूं, तो अब आपके पास वास्तविक समस्या यह है कि आपके पास चर-लंबाई डेटा है, जो वास्तव में है numpy की ताकत में से एक नहीं है, और यही कारण है कि आप प्रदर्शन मुद्दों में चल रहे हैं।जब तक कि आप पहले से किसी मल्टीएवेंट के लिए प्रविष्टियों की अधिकतम संख्या में नहीं जानते हैं, तो आपको समस्याएं आती हैं, और फिर भी आप उन घटनाओं के लिए शून्य से भरे मेमोरी/डिस्क स्पेस के भार को बर्बाद कर देंगे जो बहु घटना नहीं हैं।

आपके पास एक से अधिक फ़ील्ड वाले डेटा पॉइंट हैं, जिनमें से कुछ अन्य फ़ील्ड से संबंधित हैं, और इनमें से कुछ समूहों में पहचानने की आवश्यकता है। यह दृढ़ता से संकेत देता है कि आपको प्रदर्शन, स्मृति, स्पेस-ऑन-डिस्क और सैनिटी कारणों के लिए, इस जानकारी को संग्रहीत करने के लिए किसी फ़ॉर्म के डेटाबेस पर विचार करना चाहिए।

जटिल, हैक-ऑन-नम्पी संरचना की तुलना में एक सरल डेटाबेस स्कीमा को समझने के लिए आपके कोड के लिए एक व्यक्ति के लिए यह बहुत आसान होगा जो निराशाजनक रूप से धीमा और फुलाएगा। तुलना में एसक्यूएल प्रश्न त्वरित और लिखने में आसान हैं।

मैं इवेंट और मल्टीवेन्ट टेबल वाले स्पष्टीकरण की अपनी समझ के आधार पर सुझाव दूंगा, जहां प्रत्येक इवेंट एंट्री में मल्टीएवेंट टेबल में एक विदेशी कुंजी हो, जहां प्रासंगिक हो।

Answer 2

बेवकूफ सरणी निश्चित आकार वाले डेटा प्रकारों के लिए सबसे उपयुक्त हैं। यदि सरणी में ऑब्जेक्ट्स निश्चित आकार नहीं हैं (जैसे आपका मल्टीवेन्ट) ऑपरेशन बहुत धीमे हो सकते हैं।

मैं आपको सभी क्षेत्रों के साथ 1 डी रैखिक रिकॉर्ड सरणी में 3 फ़ील्ड: event_id, समय, अवधि के साथ स्टोर करने की सलाह दूंगा। प्रत्येक घटना सरणी में mutliple बार दिखाई दे सकते हैं:

>>> import numpy as np 
>>> rawdata = [(1, 0.4, 4), (1, 0.6, 6), (2,2.6, 6)] 
>>> npdata = np.rec.fromrecords(rawdata, names='event_id,time,period') 
>>> print npdata 
[(1, 0.40000000000000002, 4) (1, 0.59999999999999998, 6) (2, 2.6000000000000001, 6)] 

एक विशिष्ट सूचकांक के लिए डेटा प्राप्त करने के लिए आप कल्पना अनुक्रमण इस्तेमाल कर सकते हैं:

>>> eventdata = npdata[npdata.event_id==1] 
>>> print eventdata 
[(1, 0.40000000000000002, 4) (1, 0.59999999999999998, 6)] 

इस दृष्टिकोण का लाभ यह है कि आप आसानी से इसे के साथ intergrate कर सकते हैं आपके ndarray- आधारित कार्यों।

cdef packed struct Event: 
    np.int32_t event_id 
    np.float64_t time 
    np.float64_6 period 

def f(): 
    cdef np.ndarray[Event] b = np.zeros(10, 
     dtype=np.dtype([('event_id', np.int32), 
         ('time', np.float64), 
         ('period', np.float64)])) 
    <...>