Introduction to MapReduce-XWNEhv-b2PM

हैलो, इसलिए हम क्लाउड कंप्यूटिंग पर हमारी चर्चा जारी रखेंगे।
 जैसा कि हमारे पिछले व्याख्यान में हमने डेटा स्टोर या डेटा के बारे में चर्चा की थी, जिसमें क्लाउड में डेटा का प्रबंधन कैसे किया जा रहा था।
 अब, हम देखना चाहते हैं कि एक और प्रोग्रामिंग प्रतिमान जो मैपरेडस को कॉल करता है, वह एक बहुत ही लोकप्रिय प्रोग्रामिंग प्रतिमान है जो मुख्य रूप से Google द्वारा स्तरित होता है, लेकिन अब विभिन्न वैज्ञानिक उद्देश्यों के लिए उपयोग किया जा रहा है।
 इसलिए, Google ने मुख्य रूप से इसे अपने बड़े पैमाने पर खोज सर्च इंजनों के लिए विकसित किया, मुख्य रूप से उन दस्तावेजों की मात्रा की खोज करने के लिए जो उनके Google सर्च इंजन मंत्रों की खोज करते हैं, लेकिन यह इस वैज्ञानिक दुनिया के लिए इस दर्शन का शोषण करने के लिए काम करने के लिए एक महत्वपूर्ण प्रतिमान प्रोग्रामिंग प्रतिमान बन गया है।
 विभिन्न प्रकार की वैज्ञानिक समस्याओं के लिए कुशलता से निष्पादित करें।
 इसलिए, नक्शा कम करना Google पर विकसित एक प्रोग्रामिंग मॉडल है, जिसका मुख्य उद्देश्य बड़े पैमाने पर खोज को लागू करना था, बड़े तालिका या जीएफएस (GFS) वितरित फ़ाइल सिस्टम का उपयोग करके बड़े पैमाने पर स्केलेबल वेब डेटा पर पाठ प्रसंस्करण।
 इसलिए, जैसा कि हमने प्राप्त किया है कि बड़े डेटा और GFS ने फ़ाइल सिस्टम वितरित किए हैं डेटा संग्रहीत हैं।
 तो, इस बड़े पैमाने पर स्केलेबल वेब डेटा को कैसे संसाधित करें, इसका मतलब है कि डेटा की बड़ी मात्रा खेल में आ रही है।
 एक समय में दसियों हज़ार प्रोसेसर का उपयोग करके बड़े पैमाने पर समानांतर संगणना के माध्यम से डेटा की बड़ी मात्रा में प्रसंस्करण और निर्माण के लिए डिज़ाइन।
 इसलिए, मेरे पास प्रोसेसर का एक बड़ा पूल डेटा का एक बड़ा पूल है और मैं इसमें से कुछ विश्लेषण करना चाहता हूं।
 तो, मैं इसे कैसे कर सकता हूं? इसलिए, एक बहुत ही लोकप्रिय समस्या जो हम देखते हैं वह यह है कि अगर मेरे पास बड़ी मात्रा में डेटा और प्रोसेसर की संख्या है तो कैसे कहूं कि किसी तरह के शब्द की गिनती करना चाहते हैं या उस डेटा की भारी मात्रा में कुछ शब्दों की आवृत्ति गिनना चाहते हैं।
 जैसे मैं यह पता लगाना चाहता हूं कि आईआईटी खड़गपुर डेटा के इस विशाल हिस्से में कितनी बार दिखाई देता है, जो मुख्य रूप से इस एचडीएफएस या जीएफएस या बड़े टेबल प्रकार के आर्किटेक्चर में संग्रहीत हैं।
 तो, और यह दोष सहिष्णु होना चाहिए, प्रोसेसर की विफलता और नेटवर्क विफल होने पर भी गणना की प्रगति सुनिश्चित करें।
 इसलिए, चूंकि बड़ी मात्रा में प्रोसेसर बड़ी संख्या में हैं और नेटवर्क को रेखांकित करते हैं, इसलिए मैं गलती सहिष्णु सुनिश्चित करता हूं।
 इसलिए, उदाहरण में से एक है Hadoop ओपन सोर्स कार्यान्वयन मानचित्र का परिचय (Map Reduce) का समय पर विकसित किया गया था जो शुरू में याहू पर विकसित हुआ था और फिर एक खुला स्रोत बन गया था।
 Amazon EC 2 प्लेटफ़ॉर्म पर दाईं ओर पहले से पैक AMI में उपलब्ध है।
 इसलिए, हम जो देख रहे हैं, वह एक प्रोग्रामिंग प्लेटफॉर्म या प्रोग्रामिंग प्रतिमान प्रदान करने की कोशिश कर रहा है, जो डेटा बेस के साथ इंटरैक्ट कर सकता है, जो इस तरह के क्लाउड डेटा स्टोर में स्टोर किए जाते हैं, यह एचडीएफएस, जीएफएस प्रकार या द्वारा प्रबंधित किया जा सकता है।
 बड़ी मेज और इतने पर।
 इसलिए, यदि हम फिर से समानांतर कंप्यूटिंग (Parallel Computing) को देखते हैं जैसा कि हमने अपने पिछले व्याख्यानों में देखा है, इसलिए समानांतर कंप्यूटिंग के विभिन्न मॉडल प्रोसेसर की प्रकृति और विकास, मल्टीप्रोसेसर कंप्यूटर आर्किटेक्चर (Multi-processor Architecture) पर निर्भर करते हैं।
 तो, यह साझा मेमोरी मॉडल, वितरित मेमोरी मॉडल है, इसलिए ये 2 लोकप्रिय चीजें हैं।
 इसलिए, कंप्यूटिंग के लिए विकसित समानांतर कंप्यूटिंग, गहन वैज्ञानिक कार्यों के रूप में हम सभी जानते हैं; बाद में डेटा बेस क्षेत्र या डेटा बेस प्रतिमान में भी सही पाया गया।
 इसलिए, यह शुरू में यह एक बड़ा वैज्ञानिक कार्य करने से अधिक था और बाद में हमने देखा है कि डेटाबेस डोमेन में भी इसका बहुत अधिक अनुप्रयोग है।
 और हमने अपने पहले के व्याख्यान में देखा है कि हमारे पास तीन प्रकार का परिदृश्य है एक साझा मेमोरी, साझा डिस्क और साझा कुछ भी नहीं, सही है।
 इसलिए, जब भी हम एक प्रोग्रामिंग प्रतिमान करना चाहते हैं या किसी ऐसी चीज पर काम करना चाहते हैं जो इस तरह के समानांतर प्रोग्रामिंग प्रतिमान पर काम कर सकती है, जहां डेटा इस तरह के बादलों के भंडारण में संग्रहीत होता है, इसलिए हमें इस बात का ध्यान रखना होगा कि किस प्रकार का तंत्र है।
 क्या आप वहां मौजूद हैं।
 जैसे, चाहे वह साझा मेमोरी, साझा डिस्क या साझा कुछ भी प्रकार का कॉन्फ़िगरेशन नहीं है।
 यह वह तस्वीर है जिसे हमने पहले से ही हमारे पूर्व व्याख्यान में देखा है, इसलिए हम दोहराना नहीं चाहते हैं।
 तो, यह एक साझा स्मृति संरचना है, साझा डिस्क और कुछ भी साझा नहीं है, लेकिन परिप्रेक्ष्य जिसे हम अब देख रहे हैं वह थोड़ा अलग है।
 वहां अधिक भंडारण है जहां हम देख रहे हैं।
 अब, हम यह देखने की कोशिश कर रहे हैं कि प्रोग्रामिंग इस प्रकार की संरचना का कैसे फायदा उठा सकती है।
 तो, यह पहले से ही हमने देखा है; इसलिए, कई सीपीयू के साथ सर्वर के लिए उपयुक्त साझा मेमोरी।
 स्वतंत्र सर्वर के कुछ भी क्लस्टर को अपनी हार्ड डिस्क के साथ साझा नहीं किया है, इसलिए एक उच्च गति नेटवर्क द्वारा जुड़ा हुआ है।
 और साझा डिस्क, इसलिए यह एक हाइब्रिड आर्किटेक्चर स्वतंत्र सर्वर क्लस्टर शेयर है जो NAS या SAN जैसे उच्च गति नेटवर्क भंडारण के माध्यम से भंडारण करता है।
 क्लस्टर मानक ईथरनेट के माध्यम से भंडारण के माध्यम से जुड़े हुए हैं, फास्ट फाइबर चैनल infini- बैंड (Infini-Band) और इतने पर और आगे।
 इसलिए, जब भी हम समानांतर या कुछ भी समानांतर कंप्यूटिंग या समानांतर भंडारण और चीजों के प्रकार करते हैं, तो हमारे दिमाग का जो कुछ है वह दक्षता अधिकार है।
 तो, आप एक प्रमुख पहलू के लिए समानता करना चाहते हैं एक दक्षता है।
 गलती सहिष्णुता और पूर्ण सबूत और विफलता रजिस्टर और बात के प्रकार के अन्य पहलू हो सकते हैं, लेकिन मुख्य रूप से यह कुशल होना चाहिए।
 अब, सबसे पहले हम वहां जो भी काम कर रहे हैं, उसमें निहित समानता होनी चाहिए।
 यदि कोई अंतर्निहित समानता नहीं है, तो यह हमेशा एक समानांतर वास्तुकला का उपयोग करने के लिए फलदायी नहीं हो सकता है।
 तो, सबसे पहले उन्हें समानांतर होना चाहिए यह ऑपरेशन का अनुक्रम नहीं होना चाहिए और फिर आप एक समानांतर करने की कोशिश करेंगे।
 तो, यह नौकरी 1, नौकरी 2, नौकरी 3, नौकरी 4 एक अनुक्रम है या कुछ समानता के बीच में है, लेकिन यदि आप एक समानांतर ऑपरेशन करना चाहते हैं, तो नहीं हो सकता है।
 इसलिए, यदि कोई कार्य यू-प्रोसेसर में समय लेता है, तो पी द्वारा टी लेना चाहिए यदि पी प्रोसेसर में निष्पादित किया जाता है आदर्श रूप से यदि समानता है, और हम सोच रहे हैं कि वितरण और चीजों के प्रकार को विभाजित करने में कोई लागत नहीं है।
 तो, यह आदर्श रूप से T by P एक आदर्श स्थिति है जो हमारे पास हो सकती है।
 तो, प्रोसेसर के बीच सिंक्रनाइज़ेशन की आवश्यकता के कारण वितरित संगणना में शुरू की गई अक्षमताएं।
 इसलिए, मुझे प्रोसेसर के बीच सिंक्रनाइज़ करने की आवश्यकता है, यह ऐसा नहीं है कि सभी प्रोसेसर आपके पास व्यक्तिगत घड़ियां हो सकते हैं और आपको यह सिंक्रनाइज़ करने की आवश्यकता है कि जहां चीजें होंगी।
 अन्यथा यदि आप नौकरी को 2 में विभाजित करते हैं, जहां एक को अब निष्पादित किया जाता है और एक को कुछ घंटों के बाद निष्पादित किया जाता है, तो यह बेहतर है कि एक सिस्टम में निष्पादित हो सकता है।
 तो, प्रोसेसर के बीच सिंक्रनाइज़ेशन महत्वपूर्ण पहलुओं में से एक है।
 तो, सिंक्रनाइज़ करने की आवश्यकता है।
 प्रोसेसर के बीच संदेश संचार के ओवरहेड्स एक और पहलू; एक और प्रोसेसर को काम के वितरण में असंतुलन, इसलिए यह समान रूप से विभाजित और चीजों का प्रकार नहीं हो सकता है।
 तो, ये विभिन्न पहलू हैं जो अप्रत्यक्ष रूप से इस दक्षता को प्रभावित करते हैं या इस समानांतर कार्यान्वयन में अक्षमता लाते हैं।
 इसलिए, एक एल्गोरिथ्म की समानांतर दक्षता को टी द्वारा पी द्वारा पी के रूप में टी द्वारा पी के रूप में परिभाषित किया जा सकता है।
 इसलिए, अगर यह है तो हम कहते हैं कि यह स्केलेबल है या स्केलेबल समानांतर दक्षता स्थिर रहती है क्योंकि डेटा का आकार इसी की वृद्धि के साथ बढ़ता गया।
 प्रोसेसर।
 इसलिए, जब अधिक डेटा आ रहा है तो क्या हो रहा है, इसलिए आप अधिक प्रोसेसर को तैनात करते हैं या आप क्लाउड से अधिक प्रोसेसर के अनुरोध पर जाते हैं और फिर आपकी दक्षता स्थिर रहती है, दक्षता मान नहीं बदलते हैं? तो, फिर हम क्या कहते हैं कि यह स्केलेबल है।
 इसलिए, अगर मैं दोनों को उदाहरण के लिए, रैखिक रूप से बढ़ाता हूं तो यह निरंतर बात में आगे बढ़ता है।
 प्रोसेसर की निश्चित संख्या के लिए डेटा के आकार के साथ समानांतर दक्षता बढ़ जाती है, यह डेटा के आकार के साथ बढ़ जाती है; और अगर यह प्रोसेसर की निश्चित संख्या है तो हमारे पास प्रभावी रूप से अधिक दक्षता हो सकती है।
 अब, उदाहरण, जो उस किताब में है, जिसका आप जिक्र कर रहे हैं, आपको अलग-अलग साहित्य में उदाहरण मिलेगा, इस तरह का उदाहरण नहीं है।
 दस्तावेजों के एक बहुत बड़े संग्रह पर विचार करें पूरे वेब द्वारा क्रॉल किए गए वेब दस्तावेज़ का कहना है।
 तो, यह बहुत बड़ा है यह हर दिन बड़ा हो रहा है यह बढ़ रहा है।
 समस्या उस आवृत्ति को निर्धारित करना है जो इस संग्रह में प्रत्येक शब्द की घटनाओं की कुल संख्या है।
 इसलिए, मैं इस दस्तावेज़ में प्रत्येक शब्द की आवृत्ति की कुल संख्या निर्धारित करना चाहता हूं।
 इसलिए, इस प्रकार यदि n दस्तावेज़ और मी अलग-अलग शब्द हैं, तो हम प्रत्येक शब्द सही के लिए m आवृत्ति एक निर्धारित करने के लिए उपयोग करते हैं।
 तो, यह एक सरल समस्या सच हो सकती है या खोज इंजन और चीजों के प्रकार के लिए अधिक प्रासंगिक हो सकती है।
 इसलिए, हमारे पास दो दृष्टिकोण हैं जो प्रत्येक प्रोसेसर को पी शब्दों द्वारा मी के लिए आवृत्ति की गणना करते हैं।
 इसलिए, प्रत्येक प्रोसेसर, अगर पी प्रोसेसर हैं, तो जिस एम फ्रीक्वेंसी की मुझे गणना करने की आवश्यकता है, मैं पी को एम से विभाजित करता हूं, इतने सारे, उदाहरण के लिए, मैं चाहता हूं कि मेरे पास दस प्रोसेसर हैं और मेरे पास नहीं है मैं कुछ के लिए देख रहा हूं 90 शब्द, मी नब्बे के बराबर।
 तो, हर प्रोसेसर दस सही का हिस्सा करता है अगर यह विभाज्य नहीं है तो आपको कुछ असममित विभाजन बनाना होगा।
 इसलिए, यह चीजों को बनाता है और चीजों के अंत में वे फिर से चीजों को एक साथ या किसी न किसी प्रणाली के माध्यम से रिपोर्ट करते हैं।
 तो, दूसरे तरीके से प्रत्येक प्रोसेसर को पी दस्तावेजों द्वारा एन शब्द भर की आवृत्ति की गणना करने दें।
 तो, दस्तावेजों की कुल संख्या 10,000 कहती है।
 इसलिए, 10,000 नंबर के शब्द जिन्हें मैं 90 नंबर के प्रोसेसर के लिए देख रहा हूं, जो कि मेरे पास हैं।
 10. इसलिए, हर एक प्रोसेसर के लिए दिए गए औसतन 9 शब्दों में से एक 10 है, जो 9 हैं।
 दूसरी बात जो हम बता रहे हैं कि प्रत्येक प्रोसेसर सभी 90 शब्दों के लिए आवृत्ति की गणना करता है, लेकिन n दस्तावेज़ पर p द्वारा यदि 10,000 शब्द और फिर p 10 प्रोसेसर; इसलिए, कुछ हजार दस्तावेज़ तो प्रत्येक 100 दस्तावेज़ लेते हैं और प्रसंस्करण करते हैं और एक बार व्यक्तिगत प्रोफेसरों प्रोसेसर द्वारा इस मी शब्दों की आवृत्ति निकलती है तो मैं इस चीज़ को जोड़ देता हूं और एकत्र करता हूं और परिणाम दिखाता हूं कि यह सही है, इसके बाद सभी प्रोसेसर अपने परिणामों को सही बताते हैं।
 समानांतर कंप्यूटिंग, अब जो इस समानांतर कंप्यूटिंग प्रतिमान के आधार पर कुशल होगा, हमें सही देखने की जरूरत है।
 इसलिए, समानांतर कंप्यूटिंग को एक साझा डिस्क के साथ वितरित मेमोरी मॉडल के रूप में लागू किया जाता है, ताकि प्रत्येक प्रोसेसर डिस्क से किसी भी दस्तावेज़ को बिना किसी विवाद के समानांतर एक्सेस करने में सक्षम हो।
 तो, यह कार्यान्वयन तंत्रों में से एक हो सकता है।
 अब, दस्तावेज़ से प्रत्येक शब्द को पढ़ने का समय कहता है यदि हम मान लेते हैं कि दस्तावेज़ से प्रत्येक शब्द को समय के बराबर पढ़ने के लिए समय है, तो दूसरे प्रोसेसर को शब्द भेजने के लिए अंतर प्रोसेसर संचार और सी के बराबर है।
 तो, बात को सरल बनाना तो यह हो सकता है आदर्श रूप में आदर्श मामले में या वास्तविक जीवन के मामले में इसका मतलब अलग होना चाहिए, लेकिन हम इन परिदृश्यों को बनाते हैं।
 तो, पहले समय के लिए इतने समय के लिए अप्रोचिंग आवृत्तियों के एक कुल में जोड़ने के लिए नगण्य है, इसलिए संक्षेप में नगण्य है।
 एक बार जब मुझे इस m शब्द की आवृत्तियों का पता चलता है तो संक्षेप में नगण्य है।
 दस्तावेज़ पर प्रत्येक बार औसतन क्या शब्द होता है।
 इसलिए, अगर मैं अपनी गणना के लिए यह कहूं कि प्रत्येक शब्द औसतन कुछ एफ श्रमिकों का है।
 एकल प्रोसेसर के साथ सभी m आवृत्तियों की गणना करने का समय तब तक बराबर होता है जब तक कि मैं n को c में f में n कर देता हूं।
 तो, यह एक प्रोसेसर के साथ m आवृत्तियों की गणना करने का समय है, अगर मेरे पास एक एकल प्रक्रिया है तो यह बात हो सकती है।
 इसलिए, यदि हम पहला दृष्टिकोण करते हैं, तो पहला दृष्टिकोण यह था, प्रत्येक प्रोसेसर को पी शब्दों द्वारा मीटर की आवृत्ति की गणना करने दें, ताकि यह पहला दृष्टिकोण हो।
 इसलिए, प्रत्येक प्रोसेसर अधिकतम n में m से f समय में पढ़ता है।
 इसलिए, समानांतर दक्षता की गणना pnmfc द्वारा nffc के रूप में की जाती है, इसलिए p बहुत वेनिला प्रकार के विचार से।
 इसलिए, हम लेते हैं कि सभी नैतिक रूप से समान आवृत्तियों हैं, सभी किसी भी एकत्रीकरण के लिए नगण्य समय हैं, फिर साधनों को पढ़ने और लिखने के लिए हर समय हमें सी पर विचार करना होगा, इस पर विचार करते हुए हम पी द्वारा 1 प्राप्त कर रहे हैं।
 तो, दक्षता बढ़ती पी के साथ आती है।
 तो, अगर हम पी बढ़ाते हैं, तो दक्षता गिर जाती है।
 तो, यह स्थिर नहीं है।
 तो, यह स्केलेबल नहीं है, यह एक बड़ी समस्या यह है कि हालांकि यह वही है जिसे हम वगैरह को कंसेप्टाइज़ करना आसान कहते हैं, लेकिन स्केलेबिलिटी में कोई समस्या है।
 यह एक ऐसा है जो प्रत्येक प्रोसेसर को m शब्दों द्वारा n शब्दों के अनुसार प्रति n आवृत्तियों की गणना करता है, स्केलेबल नहीं है।
 जबकि, दूसरे दृष्टिकोण में, जहां हम उस शब्द को अलग-अलग प्रक्रियाओं में विभाजित करते हैं, ओह माफ करना, हम उस दस्तावेज़ को विभाजित करते हैं d, जबकि हर प्रोसेसर सभी m शब्दों के लिए यह गणना करता है और फिर एकत्र करता है।
 इसलिए, जाहिर है कि ऐसा लगता है कि यह मुझे अधिक महंगा हो सकता है।
 तो, यह एक एकत्रीकरण की बात है तो आप उन प्रोसेसर को क्लब कर रहे हैं, क्लब का अर्थ है एम सेट को अलग-अलग विभाजन में सेट इस पूरे दस्तावेज़ को अलग करना और ऐसा करना, यह पहले वाले की तुलना में कुशल हो सकता है।
 लेकिन हम देखते हैं कि क्या है।
 तो, प्रत्येक प्रोसेसर के लिए रीड पर्फॉर्म की संख्या n से p में m से f सही संख्या में होती है पढ़ने के लिए लिया गया समय n m से f में n होता है।
 ऐसा इसलिए है क्योंकि आप डेटा की मात्रा के p मात्रा से n हो रहे हैं और फिर m से c में f की गणना करना चाहते हैं, इसलिए इस पढ़ने की गणना करने के लिए समय की संख्या।
 डिस्क के समानांतर m शब्दों पर आंशिक आवृत्ति लिखने के लिए लिया गया समय m में c में m है।
 इसलिए, एक बार जब आपको किया जाता है, तो आपको डिस्क के समानांतर पर लिखने की आवश्यकता होती है और वह यह है कि पी माइनस 1 प्रोसेसर के लिए आंशिक आवृत्ति को संवाद करने के लिए मी समय में c c लिया जाता है।
 और फिर स्थानीय रूप से सब पी पी वेक्टर्स को जोड़कर फ़्रीक्वेंसी के अंतिम मी वेक्टर के एक के बाद एक उत्पन्न करने के लिए जो हम पी से पी में मीटर में पी।
 इसलिए, आपको आंशिक आवृत्तियों को संप्रेषित करने के लिए हमें समय देने की आवश्यकता है, क्योंकि आपके पास संपूर्ण आवृत्तियां नहीं हैं।
 इसलिए, अलग-अलग प्रोसेसर और पी माइनस 1 प्रोसेसर द्वारा आंशिक फ्रीक्वेंसी और फिर स्थानीय रूप से p सब वेक्टर्स को जोड़कर 1 m पी वेक्टर फ्रिक्वेंसी के यहाँ उत्पन्न करने के लिए यह एक है।
 इसलिए, व्यक्तिगत रूप से करने की जरूरत है।
 इसलिए, यदि हम इस दूसरे दृष्टिकोण के मामले में उन सभी चीजों को अपनाते हैं जो हमारे पास इस संरचना के रूप में समानांतर आवृत्ति हैं, तो 1 1 से 1 प्लस 2 पी।
 पुस्तक, यह एक बहुत कठिन समस्या नहीं है जिसे कम करना मुश्किल है।
 यह बहुत आसान है बस कदम दर कदम जाना है।
 अब, यह एक दिलचस्प घटना है।
 इसलिए, हम जो शब्द यहां देख रहे हैं वह n m द्वारा 1 plus 2 p है।
 तो, इस मामले में एक पी कई है, एनएफ से कई गुना कम है।
 दूसरे दृष्टिकोण की दक्षता यहां पहले अधिकार की तुलना में अधिक है यदि यह पी है, तो कई, एनएफ से कई गुना कम है, तो यह शब्द एक की ओर झुकाव होगा।
 और यह महसूस किया जा सकता है कि दक्षता बहुत अधिक है।
 पहले दृष्टिकोण में, इसलिए एक प्रकार है यह होना चाहिए, पहले दृष्टिकोण में हमें प्रत्येक प्रोसेसर को कई शब्दों को पढ़ना पड़ता है क्योंकि इसे पढ़ने के लिए समय की बर्बादी की आवश्यकता होती है।
 हमने पहले दृष्टिकोण में क्या किया है इस कई प्रोसेसर को हमने इस मीटर को अलग-अलग चंक में विभाजित किया है।
 इसलिए, प्रोसेसर का कहना है कि जैसा कि हमने उदाहरण लिया है कि अगर मैं नब्बे के रूप में मीटर हूं और प्रोसेसर की संख्या p है, तो 90 p से 10. है।
 इसलिए, हर किसी को 10 मिल रहा है, लेकिन जब यह पूरे दस्तावेज़ को खोज रहा है , इसलिए दस्तावेजों की संख्या पढ़ रही है जहां कोई हिट नहीं है, यह कोई सफलता नहीं है।
 इसलिए, दक्षता, इसलिए दूसरे दृष्टिकोण में हर रीड उपयोगी है।
 जैसा कि यह एक संगणना में परिणत होता है और अंतिम परिणामों को वितरित करता है।
 इसलिए, दूसरे दृष्टिकोण के लिए, हर रीड उपयोगी होने की संभावना है जहां यह इस परिणाम में योगदान देता है।
 तो, यह भी स्केलेबल है।
 दक्षता n और p दोनों पर स्थिर रहती है और संभावित रूप से बढ़ती है, वे आनुपातिक रूप से।
 इसलिए, हम देखते हैं कि हमने वहां क्या किया है कि अगर मेरा डेटा लोड बढ़ता है तो मैं प्रोसेसर बढ़ाऊंगा।
 इसलिए, अगर मैं आनुपातिक रूप से डेटा प्रोसेसर बढ़ाता हूं तो मेरी दक्षता इस मामले में दूसरे मामले में स्थिर रहती है।
 दक्षता निश्चित पी के लिए एक को जाता है और धीरे-धीरे एन बढ़ रहा है।
 तो, दक्षता 1 तक जाती है, अगर प्रोसेसर की संख्या तय हो गई है और धीरे-धीरे बढ़ी है हम n बढ़ रहे हैं इसका मतलब है कि हम डेटा लोड बढ़ा रहे हैं, प्रोसेसर की संख्या तय हो गई है और यह मूल रूप से एक के पास जाएगा।
 इसलिए, इन संदर्भों के साथ या इन पृष्ठभूमि के साथ जो यह हो सकता है कि यह व्यक्तिगत रूप से कर रहा है तो इस चीज के साथ समेकन अधिक कुशल हो रहा है, हम देखते हैं कि आपका नक्शा मॉडल को कम करता है।
 तो, यह एक समानांतर प्रोग्रामिंग अबास्ट्रक्शन (Parallel SPrograming Extraction) है जो कई अलग-अलग समानांतर अनुप्रयोगों द्वारा उपयोग किया जाता है जो हजारों प्रोसेसर से जुड़े बड़े पैमाने पर गणना करता है; एक सामान्य अंडरलाइनिंग गलती सहिष्णु कार्यान्वयन का लाभ उठाता है।
 मानचित्र के दो चरण नक्शा संचालन को कम करते हैं और संचालन को कम करते हैं।
 एम मैपर की कॉन्फ़िगर करने योग्य संख्या - मैपर प्रोसेसर और आर रेड्यूसर प्रोसेसर (Reducer Processor) को समस्या पर काम करने के लिए असाइन किया गया है।
 गणना एक मास्टर प्रक्रिया द्वारा समन्वित है।
 तो, अब हम क्या कर रहे हैं? अलग-अलग मैपर प्रोसेसर हैं और एक अलग रेड्यूसर प्रोसेसर है।
 तो, पूरी प्रक्रिया, मैं दो चीजों में विभाजित हूं।
 जैसे कि मेरे पास एक मैपर है, तो अलग मैपर प्रोसेसर है, इसलिए एम प्रोसेसर हैं और वहां रेड्यूसर है।
 तो, अलग reducer प्रोसेसर हैं।
 तो, जब डेटा यहां आते हैं तो हम यह करते हैं कि यह मूल रूप से कुछ निष्पादन करता है और फिर यह reducer समस्या के प्रकार पर आधारित हो सकता है जो चीजों को कम करने और निष्पादन करने पर होगा।
 तो, रेड्यूसर उत्पन्न होगा कुल मिलाकर कुल परिणाम।
 तो, यह करने की कोशिश करता है यह एक समानांतर प्रोग्रामिंग अबास्ट्रक्शन है जो खनिज समानांतर अनुप्रयोगों द्वारा उपयोग किया जाता है जो हजारों प्रोसेसर से बड़े पैमाने पर गणना का आयोजन करता है।
 तो, यहां आवेदन खेल में आ गया है।
 तो, यह एक दो चरण की प्रक्रिया है, एक नक्शा ऑपरेशन है, दूसरा एक कम ऑपरेशन है।
 तो, एम मैपर प्रोसेसर, आर reducer प्रोसेसर की विन्यास योग्य संख्या, तो यह विन्यास योग्य है; इसका मतलब है, आप अधिक इत्यादि मैपर और reducer हो सकता है।
 तो, नक्शा चरण को कम करें।
 इसलिए, यदि हम मानचित्र चरण को देखते हैं तो प्रत्येक मैपर वैश्विक फ़ाइल से इनपुट के लगभग एक को पढ़ता है।
 तो, यह पूरा डेटा डी नहीं है, लेकिन डेटा का एक हिस्सा पढ़ा है।
 मानचित्र संचालन में मूल्य कुंजी मान जोड़ी के एक सेट को मुख्य मूल्य जोड़ी के दूसरे सेट में बदलने का होता है।
 तो, कौन सा नक्शा करता है, यह मुख्य मूल्य जोड़ी का एक सेट है जो कि प्रमुख मूल्य जोड़ी के दूसरे सेट पर है।
 तो, नक्शा के 1 वी 1 से के 2 v2।
 इसलिए, प्रत्येक मैपर प्रति रेड्यूसर में एक फ़ाइल में कम्प्यूटेशनल परिणाम लिखता है।
 तो, यह क्या करता है, यह मूल रूप से प्रत्येक reducer के लिए एक फाइल पैदा करता है।
 तो, यह कहता है कि अगर Reducers आर 1, आर 2, आर 3 एक मैपर एम हैं, तो मैं reducer के आधार पर तीन फाइलें बनाते हैं।
 इसलिए, फ़ाइलों को एक कुंजी द्वारा क्रमबद्ध किया जाता है और स्थानीय फाइल सिस्टम में संग्रहीत किया जाता है।
 मास्टर इन फ़ाइलों के स्थान के ट्रैक रखता है।
 इसलिए, एक मास्टर मैप मास्टर को कम करता है, इसलिए फ़ाइल के इस स्थान का ख्याल रखता है, प्रत्येक मैपर प्रत्येक रेड्यूसर के लिए एक फाइल बनाता है और मास्टर स्थानीय डिस्क इत्यादि में फाइलों को संग्रहीत करते हैं, जहां देखभाल करता है।
 कम चरण में, मास्टर रिड्यूसर्स को सूचित करता है जहां संबंधित मैपर की स्थानीय फाइल सिस्टम पर आंशिक गणना की गई है; तो इसका मतलब है कि रिड्यूसर चरण में, रिड्यूसर इस मास्टर से परामर्श करता है जो यह सूचित करता है कि जहां इसकी संबंधित फाइलें प्रत्येक मैपिंग फ़ंक्शन के अनुरूप संग्रहीत हैं।
 Reducer फ़ाइलों को लाने के लिए मैपर्स को दूरस्थ प्रक्रिया कॉल करता है।
 इसलिए, रिड्यूसर बदले में मैपर के लिए एक दूरस्थ प्रक्रिया कॉल करता है।
 तो, यह मैप करने में कहीं न कहीं मैपर है और रिड्यूसर में विभिन्न प्रकार के वीएम वगैरह के साथ अलग-अलग संरचना में हो सकता है, जो चीजों पर आदर्श रूप से चल रहा है आदर्श रूप में यह भौगोलिक रूप से वितरित नहीं है तो चीजें काम नहीं करेंगी।
 तो, फिर भी यह उस विशेष डेटा पर काम कर रहा है जो मैपर द्वारा उत्पादित किया जाता है।
 इसलिए, प्रत्येक रिड्यूसर समूह के चरणों का परिणाम एक ही कुंजी मान कुंजी फ़ंक्शन f वगैरह का उपयोग करते हुए करता है, इसलिए k 2 v 2 k 2 f 2 v 2. तो, यहां एकत्रित कार्य खेलने में आता है।
 दूसरे अर्थ में, अगर हमें अपनी समस्या याद है।
 तो, हम क्या करते हैं कि हर डॉक्टर, हर कुंजी या हर शब्द जिसे हम आवृत्ति की गणना करना चाहते हैं, इसलिए कार्यात्मक मॉडल चीजों की आवृत्ति को संक्षेप में प्रस्तुत करता है, यह विभिन्न प्रकार की चीजों के लिए अलग हो सकता है।
 तो, यह v वगैरह में k 2 करता है।
 तो, यह यहाँ एक और महत्वपूर्ण मूल्य के लिए चला जाता है।
 अंतिम परिणाम GFS फ़ाइल सिस्टम Google फ़ाइल सिस्टम पर वापस आ जाते हैं।
 इसलिए, उदाहरण को कम करें।
 तो, अगर हम देखते हैं कि 3 मैपर, 2 रेड्यूसर हैं।
 तो, हमारे मामले में मानचित्र कार्य यह है कि डेटा d है शब्द w1, w2, wn का सेट है और यह हर वाई के लिए चीजों की गिनती के लिए उत्पादन करता है, यह मैपर के हिस्से को कितना गिनता है।
 तो, हर वाई, यह बात मायने रखता है।
 इसलिए, यदि आप देखते हैं कि क्या d1, इसमें w1, w2, w4 है; d2 ये चीजें हैं और यह इसे मायने रखता है।
 तो, हर मैपर इसे करता है, और फिर इसे मूल रूप से एक मध्यवर्ती स्थान में संग्रहीत किया जाता है जहां रीड्यूसर पढ़ता है।
 तो, यह हर रेड्यूसर के लिए हर फ़ाइल उत्पन्न करता है जैसे यह विशेष चीजें reducer के लिए एक विशेष फ़ाइल उत्पन्न करता है।
 तो, दो reducer के लिए हर मैपर फ़ाइल उत्पन्न करता है।
 तो, और reducer बदल जाता है मूल रूप से उन में जमा।
 तो, यह कहता है कि w के पास w1 है, w2 है, इसलिए w1 को 7 के रूप में, w2 को कुछ 15. के रूप में।
 इस मामले में, w3, w4 अन्य दो हैं।
 तो, reducers mapper के आउटपुट से या mappers आउटपुट से इनपुट प्राप्त करने के इनपुट से चीज़ को कम कर देता है।
 तो, मॉडल को कम करने के लिए मॉडल गलती सहनशीलता है; इसे देखने के लिए अलग-अलग तरीके हैं, एक दिल का धड़कन संदेश है।
 तो, हर विशेष समय अवधि, यह कहती है कि क्या यह एक जीवित और चीजों की तरह है।
 संचार मौजूद है, लेकिन संचार होने पर कोई प्रगति मास्टर मौजूद नहीं है, लेकिन कोई प्रगति मास्टर उन कार्यों को डुप्लिकेट नहीं करता है और प्रोसेसर को असाइन करता है जो पहले ही पूरा हो चुका है या कुछ मुफ्त प्रोसेसर हैं।
 यदि मैपर विफल रहता है, तो मैपर फिर से निष्पादन पर किसी अन्य कार्य नोड को निर्दिष्ट महत्वपूर्ण मान को पुन: असाइन करता है।
 इसलिए, यदि यह एक विफलता है तो यह चीज़ को फिर से निष्पादित करता है।
 यदि reducer विफल रहता है केवल शेष कार्य को किसी अन्य नोड को फिर से सौंपना होगा।
 चूंकि पूरा कार्य पहले से ही Google फ़ाइल सिस्टम पर लिखा गया है।
 इसलिए, यदि पूरा कार्य वहां हैं, तो वे पहले से ही Google फ़ाइल सिस्टम में हैं, शेष शेष कार्यों को पुन: असाइन करने की आवश्यकता है।
 इसलिए, यदि आप MapReduce की दक्षता की गणना करना चाहते हैं, तो डेटा D की मात्रा पर सामान्य गणना कार्य।
 इसलिए, डिस्क प्रोसेसर से डेटा लिखने के लिए uni- प्रोसेसर पढ़ने के लिए D समय लेता है।
 डिस्क से एक शब्द लिखने के पढ़ने का समय c है।
 अब, गणना कार्य को मैप डेटा स्टेज में मैपिंग स्टेज मैपिंग टाइम सेमी से डी डेटा उत्पादन और आउटपुट आरओएच डी, जैसे चरण कम समय क्र आर डी डी और आउटपुट में उत्पादित डेटा जैसे सिग्मा म्यू डी।
 में घटाया जाता है।
 मुश्किल।
 तो, मैपिंग का समय कितना है कि डी के साथ हर मैपर डेटा का उत्पादन समय कर रहा है, विशेष मैपर से है जो कि कितने समय का उत्पादन कर रहा है, हर क्रुकर के साथ गणना में रिड्यूसर समय को कम करता है और अंत में, हमारे पास वह reducer आउटपुट है।
 इसलिए, कार्य को मानचित्र में कम करने और चरणों को कम करने में ओवरहेड्स पर विचार करने से, हम निम्नलिखित संबंध रख सकते हैं।
 इसलिए, अगर हम मैपिंग और रिड्यूस करने में ओवरहेड को भूल जाते हैं, तो हमारे पास चीजों का यह योग हो सकता है।
 अब, अगर हमारे पास P प्रोसेसर हैं जो समस्या को हल करने के लिए चरणों के बावजूद मैपर और रेड्यूसर दोनों के रूप में काम करते हैं।
 इसलिए, यदि हम पी प्रोसेसर का उपयोग करते हैं तो यह कभी-कभी मैपर के रूप में कार्य करता है, कभी-कभी रेड्यूसर के रूप में कार्य करता है।
 फिर हमारे पास अतिरिक्त उपरि है प्रत्येक mapper स्थानीय को लिखता है हमारे पास कुछ अतिरिक्त ओवरहेड है जो स्थानीय डिस्क पर लिखता है और उसके बाद प्रत्येक रीड्यूसर को डिस्क पर पढ़ने के लिए दूरस्थ रूप से लिखता है।
 विश्लेषण उद्देश्य समय के लिए स्थानीय या दूरस्थ रूप से किसी शब्द को पढ़ने के लिए, आइए हम उसी के बारे में विचार करें।
 डिस्क से एक डेटा को पढ़ने का समय प्रत्येक मैपर के लिए है, यदि प्रोसेसर की संख्या P के साथ w की संख्या है, तो P डेटा D से P है।
 निर्माता mapper है, R द्वारा D से R है।
 तो , डिस्क पर वापस लिखने के लिए आवश्यक समय क्योंकि एक बार जब आप पढ़ते हैं तो आपको गणना के बाद, आपको उस पर वापस लिखना होगा।
 इसलिए, प्रत्येक विभाजन से प्रत्येक रेड्यूसर द्वारा प्रत्येक डेटा को पढ़ने के लिए डेटा पी पीप्पर पी द्वारा पीओ डी द्वारा पी।
 तो, पी वर्ग द्वारा आरओ डी।
 इसलिए, अगर हम इस तरह की गणना करते हैं तो हम कहते हैं कि नक्शा की समांतर दक्षता कार्यान्वयन को कम करती है, यह 1, 1 से 2 प्लस 2 सी को डब्ल्यू में डब्ल्यू में लाती है।
 अब, यही कारण है कि हमें यहां एक समानांतर दक्षता मिलती है।
 अब, यदि अनुक्रमण मानचित्र कम हो जाता है, तो कई प्रकार के अनुप्रयोग होते हैं, जो दस्तावेज़ों के एक बड़े संग्रह को सही अनुक्रमित कर रहा है, जो कि मुख्य रूप से Google के लिए एक प्रमुख प्रेरणा है।
 तो, वेब खोज के लिए महत्वपूर्ण पहलू और संरचित डेटा को संभालना।
 इसलिए, मैप टास्क में एक शब्द डॉक्यूमेंट को छोड़ना शामिल है, प्रत्येक शब्द के लिए आईडी आईडी रिकॉर्ड करें जैसे कि हमने w k k को W 1 में n में मैप में एक से उसके मैप w में प्रत्येक शब्द d ks में देखा है।
 इसलिए, मैं कुछ प्रकार के इंडेक्सिंग को कम कर सकता हूं, चरण समूहों को शब्दों की जोड़ी बना सकता हूं और बात में प्रवेश कर सकता हूं।
 इसलिए, मानचित्र कम करने का उपयोग करके संबंधपरक संचालन में अनुप्रयोग हैं।
 डेटा के बड़े सेट पर एसक्यूएल स्टेटमेंट रिलेशनल जॉइन, ग्रुप को एक्साइट करें।
 समानांतर डेटा बेस के लाभ बड़े पैमाने पर दोष सहिष्णुता जिसका हम शोषण करना चाहते हैं और मेरे पास उस प्रकार के कार्य हो सकते हैं जैसे कि हमने देखा है कि यह एक समूह है जो खंड और प्रकार के वगैरह हम कर सकते हैं, ताकि कुछ प्रकार के संबंधपरक संचालन हम कर सकें निष्पादित।
 तो, इनके साथ हम आज के इस अंत तक आते हैं की बात करते हैं।
 तो, हम यहां आपको एक MapReduce प्रतिमान का अवलोकन देने के लिए क्या करने की कोशिश करते हैं कि कैसे एक समस्या को समानांतर निष्पादन के एक सेट में विभाजित किया जा सकता है, जो एक मैपर नोड है जो मध्यवर्ती परिणाम बनाता है।
 और reducer नोड्स का एक सेट है जो इस डेटा को लेता है और अंतिम परिणाम सही बनाता है।
 और हम क्या कर सकते हैं जो कुछ चीजें हैं जो दिलचस्प है कि मैपर हर reducer के लिए डेटा फ़ाइल बनाता है।
 तो, यह डेटा प्रति reducer बनाया जाता है।
 इसलिए, रिड्यूसर जानता है कि डेटा कहाँ है।
 ऊपर और ऊपर एक मास्टर नियंत्रक या मैप रिड्यूसर मास्टर चीजें हैं जो आती हैं जिससे पता चलता है कि मैपर द्वारा डेटा कहां संग्रहीत किया जाता है और रीड्यूसर कैसे पढ़ेगा।
 इतना ही नहीं अगर मैपर नोड विफल हो जाता है तो चीजों को कैसे पुनः प्राप्त करें; यदि रिड्यूसर नोड विफल हो जाता है, तो कैसे पुनः लोड करना है क्योंकि चीजों को फिर से निष्पादित नहीं किया गया है या नहीं किए गए डेटा को निष्पादित नहीं किया गया है जो अभी तक निष्पादित नहीं किए गए हैं और इसी तरह आगे और आगे।
 इसलिए, इसके साथ हम आज अपना व्याख्यान बंद कर देंगे।
 धन्यवाद।