"आई लव आर" के लिए व्यावहारिक अनुप्रयोग। अनियोजित

हाब्रोज़िटेली में मैंने अपेक्षाकृत हाल ही में पीटा है।

मैं खुद को मुख्यधारा की आईटी के लिए जिम्मेदार नहीं ठहरा सकता, लेकिन मैं "बटन" भी दबाता हूं, अगर आप मिन्स्क -22 के पहले स्कूल ऐच्छिक से गिनती करते हैं, तो पहले से ही पढ़ें ... 40 साल पुराना ... (ओह, माई गॉड! वे जितने जीवित नहीं हैं!)

अरे हाँ, मैं पचाता हूँ ...
मैंने कांपने (उत्तेजना) के साथ लिखा आर के बारे में मेरी पहली पोस्ट और मुझे मिली प्रतिक्रिया से बहुत खुश हुई। किसने वादे को पूरा करने की इच्छा को और मजबूत किया और आर। के कुछ व्यावहारिक अनुप्रयोगों को दिखाया और विशेष रूप से जैव सूचना विज्ञान के क्षेत्र से, जहां आर सबसे लोकप्रिय है, और जहां हम इसके साथ मिलकर काम करते हैं।

उसी समय, यह पहली बार नहीं है जब मैंने देखा है कि आर को "प्रोटोटाइप" के लिए एक भाषा के रूप में उपयोग किया जाता है, जिसका उद्देश्य बाद में "असली" - सी ++, या, सबसे खराब, पायथन में फिर से लिखना है।

विशेष रूप से, इस पोस्ट को एक तरह से संभावनाओं की गणना के सूचकांक विधि के बारे में एक लेख द्वारा उकसाया गया था। मैं अब संभावना सिद्धांत (जो भी आसान नहीं है, जिसमें 20+ साल का शिक्षण, जिसमें टेवर भी शामिल है) के बारे में लेख में प्रस्तुतिकरण के लिए अपनी विचित्रताओं को छोड़ देता हूँ।
कैट के तहत - इस लेख से आर-कोड को "कार्यशील" (मेरी व्यक्तिपरक राय में) स्थिति में लाने का एक उदाहरण।



संक्षेप में:
प्रिय kokorins ने एक असतत यादृच्छिक चर जनरेटर के निर्माण की सूचकांक विधि के बारे में मेरी राय में एक उपयोगी लेख लिखा।
एल्गोरिथ्म के "भोले" संस्करण का वर्णन करने के लिए लेख में निम्नलिखित कोड का उपयोग किया गया था:

#Naive approach len<-10 ps<-seq(len,2, by=-1) ps<- 1/ps^2 ps<-ps/sum(ps) ss<-cumsum(ps) gen_naiv <- function() { alpha<-runif(1) return (min(which(alpha<ss))) } #sample val<-c() len<-10000 for(i in 1:len) { val<-append(val, gen_naiv()) } vals<-factor(val) plot(vals) 

मुझे एल्गोरिथ्म में दिलचस्पी थी, लेकिन उद्धृत पोस्ट से जिन कीवर्ड्स को मैंने "फेक आउट" किया, वे बहुत विशिष्ट नहीं थे, और लेखक का उपनाम - चेन - चीन में सबसे आम है, और इसलिए इंटरनेट पर सबसे अधिक में से एक है ...

आर में प्रोग्रामिंग की लेखक की "शैली" एकदम सही है (इसे हल्के ढंग से डालने के लिए), लेकिन लेख आर के बारे में नहीं था। मैंने पहली बार इसे अनदेखा करने की कोशिश की। लेकिन लेखक के आर-पाठ के लिए एल्गोरिथ्म का पता लगाने की कोशिश में, मैंने अपना धैर्य खो दिया और इस पाठ को संकेत उदाहरण के रूप में उपयोग करने का निर्णय लिया।

तो, जैसा कि पहले ही कहा गया है - कोड काम कर रहा है। लेकिन बहुत बुरा। और मैं यह दिखाने की कोशिश करूंगा कि क्या, क्यों और कैसे बेहतर करना है।

मेरा पहला संपादन केवल एक फ़ंक्शन के रूप में एक यादृच्छिक अनुक्रम उत्पन्न करने के अंतिम चरण की व्यवस्था करना है, जो यादृच्छिक संख्याओं के एक वेक्टर को वापस करने के अलावा, निष्पादन पर खर्च किए गए समय को भी प्रिंट करता है।

 len<-10 ps<-seq(len,2, by=-1) ps<- 1/ps^2 ps<-ps/sum(ps) ss<-cumsum(ps) gen_naiv <- function() { alpha<-runif(1) return (min(which(alpha<ss))) } #sample get_naive<-function(len=10000){ val<-c() st<-system.time( for(i in 1:len) { val<-append(val, gen_naiv()) }) print(st) return(val) } 

लेखक के कोड की अंतिम दो पंक्तियाँ छोड़ी जाती हैं, क्योंकि वे केवल ग्राफिक्स के लिए अभिप्रेत हैं।

आर वातावरण में निर्दिष्ट कोड निष्पादित करने के बाद, मैं अब विभिन्न लंबाई के अनुक्रम प्राप्त कर सकता हूं, साथ ही निष्पादन पर खर्च किए गए समय के बारे में पूछ रहा हूं।

 > get_naive(10) user system elapsed 0.006 0.000 0.007 [1] 8 8 8 8 9 5 8 9 9 7 > get_naive(100) user system elapsed 0.008 0.000 0.008 [1] 8 1 7 8 8 4 9 8 7 8 9 9 9 9 5 7 9 9 8 3 7 1 1 9 7 7 9 9 5 8 6 6 4 9 9 6 9 8 9 8 6 8 6 9 2 8 9 9 9 9 7 8 5 9 6 6 5 9 9 8 9 9 7 8 6 8 9 1 8 9 [71] 9 3 5 9 8 9 9 9 9 6 9 9 5 9 8 7 8 9 9 9 8 9 7 9 8 7 8 5 5 8 > 

निष्पादन पर 1 और 9 तक संख्याओं के वास्तविक छद्म यादृच्छिक अनुक्रम पर खर्च किए गए एक सेकंड के हजारवें हिस्से को स्वीकार करने के बाद, मैं चर संस्करण में फ़ंक्शन के आउटपुट को "छिपाता हूं", लेकिन मैं नमूने की लंबाई बढ़ाने पर प्रयोग जारी रखता हूं:

 > val<-get_naive(1000) user system elapsed 0.021 0.000 0.021 > val<-get_naive(10000) user system elapsed 0.342 0.011 0.354 > val<-get_naive(100000) user system elapsed 24.86 8.55 33.48 

एय-ay-ay!
गड़बड़ लग रहा है! किसी तरह रनटाइम बहुत तेजी से बढ़ रहा है।
क्या ये वास्तव में एक भोले दृष्टिकोण की समस्याएं हो सकती हैं? क्या चीनी कॉमरेड एल्गोरिथ्म कई बार तेजी से काम करता है?

मैं कार्यक्रम के अंतिम लेखक के संस्करण को तैयार करता हूं, इसे केवल समय मापने के उद्देश्य से पूरक करता हूं। मैं वांछित नमूनों की विभिन्न लंबाई के साथ निष्पादित करना शुरू कर देता हूं ...

 > get_chen(1000) user system elapsed 0.031 0.001 0.032 > get_chen(10000) user system elapsed 0.508 0.063 0.567 > get_chen(100000) user system elapsed 46.303 5.946 53.088 

Op-पा! क्या आश्चर्य की बात है ... उन्होंने हमें नीचे, कॉमरेड चेन। कुछ "बेहतर" एल्गोरिथ्म "भोले" से बेहतर काम करने से इनकार करता है। या यह है कि मेरे द्वारा उद्धृत लेखक सभी "प्रतिभा" को व्यक्त करने में सक्षम नहीं था? मैंने जानबूझकर अपनी राय में खराब कोड के अगले बैच को नहीं दिखाया। बेहतर है कि इसकी आदत न डालें।

मेरी प्रारंभिक योजना एक सहयोगी की गलतियों को सुलझाने के लिए कदम से कदम थी और दिखाती थी कि कैसे। लेकिन मैंने टिप्पणी के साथ कोड ("भोले" संस्करण) को फिर से लिखने का फैसला किया, जैसा कि मैं आर के साथ अपने अनुभव के आधार पर और अपने स्वयं के या चीनी कोड की खामियों से लड़ने के लिए कोकोरिन को छोड़ दूंगा । क्षमा करें - मैं अभी नहीं कर सका

यहाँ कोड है जो मुझे मिला है:

 M<-10 #    ps<- 1/(M:2)^2 #     ;   -   ps<-ps/sum(ps) #      ss<-c(0,cumsum(ps)) #     lbs=1:(M-1) #  "  " () --    ,     get_vladob <- function(n, brks=ss, labs=lbs) { st<-system.time( val<-as.numeric(cut(runif(n), breaks=brks, labels=labs)) ) print(st) return(val) } 

और "रन" के परिणाम

 > val<-get_vladob(1000) user system elapsed 0.010 0.000 0.012 > val<-get_vladob(10000) user system elapsed 0.004 0.000 0.004 > val<-get_vladob(100000) user system elapsed 0.036 0.001 0.038 > val<-get_vladob(1000000) user system elapsed 0.581 0.029 0.606 > val<-get_vladob(10000000) user system elapsed 4.015 0.311 4.318 > val<-get_vladob(100000000) user system elapsed 38.405 3.092 41.578 

जैसा कि आप देख सकते हैं, यह "धीमी" भाषा के लिए बुरा नहीं है।

मैं अब अन्य भाषाओं के प्रति रुचि के साथ देख रहा हूं। मैं ब्याज के साथ अन्य वातावरणों में लागू एक समान परीक्षण के परिणामों को देखूंगा। विशेष रूप से, मैं बहुत उत्सुक हूं कि क्या कोकोरिन के सहकर्मी को सी ++ परिणाम और कौन से मिलेंगे।

कोड में क्या बदलाव आया है?
सबसे पहले, मैंने आर के "वेक्टर" गुणों का उपयोग किया। उदाहरण के लिए, अगर मुझे रनिफ़ फ़ंक्शन के 1000 मानों की आवश्यकता है, तो मैं प्रसंस्करण के लिए रनिफ़ (1000) और वेक्टर अभिव्यक्तियों का उपयोग करता हूं, और नहीं 1000 बार मैं लूप के लिए प्रत्येक में एक रनिफ़ कहता हूं। मेरा विश्वास करो, यह आर के लिए आवश्यक है।

दूसरा वाला। आर एक कार्यात्मक प्रोग्रामिंग भाषा है। यह वास्तव में मूल्यों के बड़े सरणियों के साथ काम करते समय आप समझते हैं कि यह कितना महान है जब आप स्मृति में मध्यवर्ती मूल्यों को रखने के विशेष प्रयासों के बिना कर सकते हैं। ज्यादातर मामलों में, यह तेजी से और अधिक मज़बूती से किया जाता है, जो कि वास्तव में मजबूत प्रोग्रामर द्वारा लिखी गई प्रणाली से होता है (कोई अपराध नहीं) हमेशा "डायरेक्ट-हैंड" उपयोगकर्ता, प्रोग्रामिंग की मूल बातें के ज्ञान के साथ।

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

सामान्य तौर पर - आर।
कृपया प्यार और मेहरबानी करें।