हडूप के शफल/सॉर्ट चरण में संख्यात्मक रूप से क्रमबद्ध कैसे करें?

Question

डेटा इस तरह दिखता है, पहले क्षेत्र एक नंबर,

3 ... 
1 ... 
2 ... 
11 ... 

है और मैं पहली बार क्षेत्र के अनुसार संख्यानुसार बजाय वर्णानुक्रम इन पंक्तियों को सॉर्ट करने, छंटाई यह इस तरह दिखना चाहिए के बाद जिसका अर्थ है, चाहते हैं

1 ... 
2 ... 
3 ... 
11 ... 

लेकिन Hadoop मुझे इस दे रही रखता है,

1 ... 
11 ... 
2 ... 
3 ... 

यह कैसे को दूर करते हैं?

Answer 1

मान लिया जाये कि आप Hadoop स्ट्रीमिंग उपयोग कर रहे हैं, तो आप KeyFieldBasedComparator वर्ग का उपयोग करने की जरूरत है।

1. डी mapred.output.key.comparator.class = org.apache.hadoop.mapred.lib.KeyFieldBasedComparator आदेश

2. स्ट्रीमिंग में जोड़ा जाना चाहिए आप का उपयोग आवश्यक छँटाई के प्रकार प्रदान करने की आवश्यकता mapred.text.key.comparator.options। कुछ उपयोगी लोगों -n हैं: सांख्यिक प्रकार, -r: रिवर्स तरह

उदाहरण:

एक पहचान नक्शाकार और निम्नलिखित कोड

यह नक्शाकार है के साथ कम करने बनाएँ। py & reducer.py

#!/usr/bin/env python 
import sys 
for line in sys.stdin:  
    print "%s" % (line.strip()) 

यह इनपुट है।

:

1 
11 
2 
20 
7 
3 
40 

txt यह आदेश

$HADOOP_HOME/bin/hadoop jar $HADOOP_HOME/hadoop-streaming.jar 
-D mapred.output.key.comparator.class=org.apache.hadoop.mapred.lib.KeyFieldBasedComparator 
-D mapred.text.key.comparator.options=-n 
-input /user/input.txt 
-output /user/output.txt 
-file ~/mapper.py 
-mapper ~/mapper.py 
-file ~/reducer.py 
-reducer ~/reducer.py 

स्ट्रीमिंग और आप आवश्यक उत्पादन

1 
2 
3 
7 
11 
20 
40 

नोट मिल जाएगा है

1. मैंने एक साधारण एक कुंजी इनपुट का उपयोग किया है। यदि आपके पास एकाधिक कुंजी और/या विभाजन हैं, तो आपको आवश्यकतानुसार mapred.text.key.comparator.options को संपादित करना होगा। चूंकि मुझे आपके उपयोग के मामले को नहीं पता है, इसलिए मेरा उदाहरण इस

2. पहचान मैपर की आवश्यकता है क्योंकि आपको एमआर नौकरी चलाने के लिए कम से कम एक मैपर की आवश्यकता होगी।

3. पहचान reducer की आवश्यकता है क्योंकि शफल/सॉर्ट चरण काम नहीं करेगा अगर यह एक शुद्ध नक्शा केवल नौकरी है।

Answer 2

हैडोप का डिफ़ॉल्ट तुलनित्र Writable प्रकार (अधिक सटीक WritableComparable) के आधार पर आपकी चाबियों की तुलना करता है। यदि आप IntWritable या LongWritable से निपट रहे हैं तो यह उन्हें संख्यात्मक रूप से सॉर्ट करेगा।

मुझे लगता है कि आप अपने उदाहरण में Text का उपयोग कर रहे हैं, इसलिए आप प्राकृतिक सॉर्ट ऑर्डर रखते हैं।

विशेष मामलों में, हालांकि, आप अपना खुद का तुलनित्र भी लिख सकते हैं।
उदाहरण के लिए: केवल परीक्षण के के लिए , यहाँ एक त्वरित नमूना है पाठ चाबियों का सॉर्ट क्रम को बदलने के लिए कैसे: यह उन्हें पूर्णांक के रूप में व्यवहार करेगा और संख्यात्मक सॉर्ट क्रम का उत्पादन करेगा:

public class MyComparator extends WritableComparator { 

     public MyComparator() { 
      super(Text.class); 
     } 

     @Override 
     public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) { 

      try { 

       String v1 = Text.decode(b1, s1, l1); 
       String v2 = Text.decode(b2, s2, l2); 

       int v1Int = Integer.valueOf(v1.trim()); 
       int v2Int = Integer.valueOf(v2.trim()); 

       return (v1Int < v2Int) ? -1 : ((v1Int > v2Int) ? 1 : 0); 

      } 
      catch (IOException e) { 
       throw new IllegalArgumentException(e); 
      } 
     } 
    } 

jobrunner वर्ग सेट में :

Job job = new Job(); 
... 
job.setSortComparatorClass(MyComparator.class);