मैप कम करना एक ढांचा है जिसे बड़ी मात्रा में डेटा को कुशलता से संसाधित करने के लिए विकसित किया गया था। उदाहरण के लिए, यदि हमारे डेटासेट में 1 मिलियन रिकॉर्ड हैं, और यह एक संबंधपरक प्रतिनिधित्व में संग्रहीत है - यह मूल्यों को प्राप्त करने और इन पर किसी भी प्रकार के परिवर्तनों को निष्पादित करने के लिए बहुत महंगा है।
उदाहरण के लिए SQL में, जन्मतिथि को देखते हुए, यह पता लगाने के लिए कि लाख रिकॉर्ड के लिए कितने लोगों की उम्र> 30 है, इसमें थोड़ा समय लगेगा, और यह केवल परिमाण के क्रम में बढ़ेगा जब क्वेरी की जटिलता बढ़ जाएगी। मैप रिड्यूस एक क्लस्टर आधारित कार्यान्वयन प्रदान करता है जहां डेटा को वितरित तरीके से संसाधित किया जाता है
एक और अच्छा उदाहरण है, फ्रेंड्स फ्रेंड्स फ्रॉम मैप कम, कॉन्सेप्ट को समझने के लिए एक शक्तिशाली उदाहरण हो सकता है, और एक अच्छी तरह से उपयोग किया जाने वाला केस।
मित्र खोज रहा है
MapReduce मूल रूप से Google पर विकसित एक फ्रेमवर्क है जो कई डोमेन में आसान बड़े पैमाने पर वितरित कंप्यूटिंग की अनुमति देता है। Apache Hadoop एक ओपन सोर्स कार्यान्वयन है।
मैं विवरणों पर प्रकाश डालूंगा, लेकिन यह दो कार्यों को परिभाषित करने के लिए नीचे आता है: एक मानचित्र फ़ंक्शन और एक कम फ़ंक्शन। मानचित्र फ़ंक्शन एक मान लेता है और कुंजी: आउटपुट जोड़े। उदाहरण के लिए, यदि हम एक मानचित्र फ़ंक्शन को परिभाषित करते हैं जो एक स्ट्रिंग लेता है और शब्द की लंबाई और कुंजी को शब्द के रूप में आउटपुट करता है, तो मैप (स्टीव) 5 पर वापस आ जाएगा: स्टीव और मैप (सवाना) 8 पर लौटेगा: सवाना । आपने देखा होगा कि मानचित्र फ़ंक्शन स्टेटलेस होता है और केवल आउटपुट वैल्यू की गणना के लिए इनपुट वैल्यू की आवश्यकता होती है। यह हमें समानांतर में मूल्यों के खिलाफ मानचित्र फ़ंक्शन को चलाने की अनुमति देता है और एक बड़ा लाभ प्रदान करता है। इससे पहले कि हम कम फंक्शन में जाएं, मैप्रेड्यूज़ फ्रेमवर्क सभी मानों को एक साथ कुंजी द्वारा देता है, इसलिए यदि मैप फ़ंक्शन निम्न कुंजी का उत्पादन करता है: मूल्य जोड़े:
3 : the
3 : and
3 : you
4 : then
4 : what
4 : when
5 : steve
5 : where
8 : savannah
8 : research
वे इस प्रकार समूहबद्ध हो जाते हैं:
3 : [the, and, you]
4 : [then, what, when]
5 : [steve, where]
8 : [savannah, research]
इन पंक्तियों में से प्रत्येक को फिर से कम फ़ंक्शन के तर्क के रूप में पारित किया जाएगा, जो एक कुंजी और मूल्यों की सूची को स्वीकार करता है। इस उदाहरण में, हम यह पता लगाने की कोशिश कर सकते हैं कि कुछ निश्चित लंबाई के कितने शब्द मौजूद हैं, इसलिए हमारा कम कार्य केवल सूची में वस्तुओं की संख्या की गणना करेगा और सूची के आकार के साथ कुंजी को आउटपुट करेगा:
3 : 3
4 : 3
5 : 2
8 : 2
कटौती भी समानांतर में की जा सकती है, फिर से एक बड़ा लाभ प्रदान करती है। हम फिर इन अंतिम परिणामों को देख सकते हैं और देख सकते हैं कि हमारे कॉर्पस में लंबाई 5 के केवल दो शब्द थे, आदि ...
मानचित्र के सबसे सामान्य उदाहरण कोपस में होने वाले शब्दों की संख्या की गिनती के लिए है। मान लीजिए कि आपके पास इंटरनेट की एक प्रति है (मैं ऐसी स्थिति में काम करने के लिए पर्याप्त भाग्यशाली रहा हूं), और आप इंटरनेट पर हर शब्द की एक सूची चाहते थे और साथ ही कितनी बार हुआ।
जिस तरह से आप दृष्टिकोण करेंगे, आपके पास मौजूद दस्तावेज़ों को तोड़ना होगा (इसे शब्दों में तोड़ना होगा), और प्रत्येक शब्द को एक मैपर पास करें। फिर मैपर शब्द को एक मूल्य के साथ वापस बाहर थूक देगा 1। समूहीकरण चरण सभी कुंजी (इस मामले में शब्द) को ले जाएगा, और 1 की सूची बना देगा। घटता चरण तब एक कुंजी (शब्द) और एक सूची (1 की सूची हर बार कुंजी इंटरनेट पर दिखाई देती है) लेती है, और सूची को सबमिट करती है। Reducer तब शब्द को आउटपुट करता है, इसके साथ ही इसकी गिनती भी होती है। जब सब कहा और किया जाता है तो आपके पास इंटरनेट पर हर शब्द की एक सूची होगी, साथ ही यह कितनी बार दिखाई दिया।
आसान है, है ना? यदि आपने कभी मैप्रेडिक के बारे में पढ़ा है, तो उपरोक्त परिदृश्य कुछ भी नया नहीं है ... यह मैप्रेडिक का "हैलो, वर्ल्ड" है। तो यहाँ एक वास्तविक विश्व उपयोग मामला है (फेसबुक वास्तव में निम्नलिखित कार्य कर सकता है या नहीं कर सकता है, यह सिर्फ एक उदाहरण है):
फेसबुक के पास दोस्तों की एक सूची है (ध्यान दें कि दोस्त फेसबुक पर एक द्वि-दिशात्मक चीज है। यदि मैं आपका मित्र हूं, तो आप मेरे हैं)। उनके पास बहुत सारे डिस्क स्थान हैं और वे हर रोज सैकड़ों लाखों अनुरोधों की सेवा करते हैं। उन्होंने अनुरोधों के प्रसंस्करण समय को कम करने के लिए गणना की पूर्व-गणना करने का निर्णय लिया है। एक सामान्य प्रोसेसिंग रिक्वेस्ट "यू एंड जो के 230 मित्र हैं"। जब आप किसी की प्रोफ़ाइल पर जाते हैं, तो आपको उन दोस्तों की एक सूची दिखाई देती है जो आपके पास हैं। यह सूची बार-बार नहीं बदलती है, इसलिए जब भी आप प्रोफ़ाइल का दौरा करते हैं, तो इसे हर बार पुनर्गणना करना बेकार होगा (यकीन है कि आप एक सभ्य कैशिंग रणनीति का उपयोग कर सकते हैं, लेकिन फिर मैं इस समस्या के लिए मैप्रेड्यूस के बारे में लिखना जारी नहीं रख पाऊंगा)। हम Mapreduce का उपयोग करने जा रहे हैं ताकि हम सभी की गणना कर सकें ' दिन में एक बार आम दोस्तों और उन परिणामों को संग्रहीत करें। बाद में यह सिर्फ एक त्वरित खोज है। हमें बहुत सारी डिस्क मिल गई हैं, यह सस्ता है।
मान लें कि मित्रों को व्यक्ति -> [दोस्तों की सूची] के रूप में संग्रहीत किया जाता है, हमारे दोस्तों की सूची तब है:
A -> B C D
B -> A C D E
C -> A B D E
D -> A B C E
E -> B C D
प्रत्येक पंक्ति एक मैपर के लिए एक तर्क होगी। दोस्तों की सूची में हर दोस्त के लिए, मैपर एक कुंजी-मूल्य जोड़ी का उत्पादन करेगा। कुंजी व्यक्ति के साथ एक दोस्त होगी। मान दोस्तों की सूची होगी। कुंजी को क्रमबद्ध किया जाएगा ताकि मित्र क्रम में हों, जिससे सभी जोड़े मित्रों को एक ही reducer पर जाना पड़े। यह पाठ के साथ व्याख्या करना कठिन है, तो चलो इसे करते हैं और देखें कि क्या आप पैटर्न देख सकते हैं। सभी मैपर्स चलने के बाद, आपके पास इस तरह की एक सूची होगी:
For map(A -> B C D) :
(A B) -> B C D
(A C) -> B C D
(A D) -> B C D
For map(B -> A C D E) : (Note that A comes before B in the key)
(A B) -> A C D E
(B C) -> A C D E
(B D) -> A C D E
(B E) -> A C D E
For map(C -> A B D E) :
(A C) -> A B D E
(B C) -> A B D E
(C D) -> A B D E
(C E) -> A B D E
For map(D -> A B C E) :
(A D) -> A B C E
(B D) -> A B C E
(C D) -> A B C E
(D E) -> A B C E
And finally for map(E -> B C D):
(B E) -> B C D
(C E) -> B C D
(D E) -> B C D
Before we send these key-value pairs to the reducers, we group them by their keys and get:
(A B) -> (A C D E) (B C D)
(A C) -> (A B D E) (B C D)
(A D) -> (A B C E) (B C D)
(B C) -> (A B D E) (A C D E)
(B D) -> (A B C E) (A C D E)
(B E) -> (A C D E) (B C D)
(C D) -> (A B C E) (A B D E)
(C E) -> (A B D E) (B C D)
(D E) -> (A B C E) (B C D)
प्रत्येक पंक्ति को एक reducer के तर्क के रूप में पारित किया जाएगा। कम करने वाला फ़ंक्शन केवल मानों की सूचियों को काट देगा और चौराहे के परिणाम के साथ उसी कुंजी को आउटपुट करेगा। उदाहरण के लिए, कम करें ((AB) -> (ACDE) (BCD)) आउटपुट (AB): (CD) होगा और इसका अर्थ है कि मित्र A और B के C और D समान मित्र हैं।
कमी के बाद परिणाम है:
(A B) -> (C D)
(A C) -> (B D)
(A D) -> (B C)
(B C) -> (A D E)
(B D) -> (A C E)
(B E) -> (C D)
(C D) -> (A B E)
(C E) -> (B D)
(D E) -> (B C)
अब जब D, B की प्रोफ़ाइल पर जाता है, तो हम जल्दी से देख सकते (B D)हैं और देख सकते हैं कि उनके तीन मित्र हैं (A C E)।