मानचित्र के साथ इस एल्गोरिदम को लागू करने में मदद की ज़रूरत है Hadoop MapReduce

Question

मेरे पास एल्गोरिदम है जो एक बड़े डेटा सेट के माध्यम से कुछ पाठ फ़ाइलों को पढ़ेगा और उन पंक्तियों में विशिष्ट शर्तों की खोज करेगा। मैंने इसे जावा में कार्यान्वित किया है, लेकिन मैं कोड पोस्ट नहीं करना चाहता था ताकि यह न लगे कि मैं इसे किसी के लिए इसे लागू करने के लिए खोज रहा हूं, लेकिन यह सच है कि मुझे वास्तव में बहुत मदद की ज़रूरत है !!! यह मेरी परियोजना के लिए योजनाबद्ध नहीं था, लेकिन डेटा सेट बहुत बड़ा हो गया, इसलिए शिक्षक ने मुझे बताया कि मुझे ऐसा करना है।

संपादित (मैं स्पष्ट किया था कि नहीं मैं previos संस्करण) डेटा सेट मैं एक Hadoop क्लस्टर पर है, और मैं अपने MapReduce कार्यान्वयन

मैं MapReduce के बारे में पढ़ रहा था बनाने के लिए और thaught है कि मैं पहले क्या करना चाहिए मानक कार्यान्वयन और फिर मैड्रिड के साथ इसे करने के लिए यह अधिक/कम आसान होगा। लेकिन ऐसा नहीं हुआ, क्योंकि एल्गोरिदम काफी बेवकूफ है और कुछ विशेष नहीं है, और मानचित्र कम हो जाता है ... मैं इसके चारों ओर अपने दिमाग को लपेट नहीं सकता।

तो यहाँ

मेरी एल्गोरिथ्म के छद्म कोड शीघ्र ही

LIST termList (there is method that creates this list from lucene index) 
FOLDER topFolder 

INPUT topFolder 
IF it is folder and not empty 
    list files (there are 30 sub folders inside) 
    FOR EACH sub folder 
     GET file "CheckedFile.txt" 
     analyze(CheckedFile) 
    ENDFOR 
END IF 


Method ANALYZE(CheckedFile) 

read CheckedFile 
WHILE CheckedFile has next line 
    GET line 
    FOR(loops through termList) 
      GET third word from line 
      IF third word = term from list 
     append whole line to string buffer 
    ENDIF 
ENDFOR 
END WHILE 
OUTPUT string buffer to file 

इसके अलावा, हर बार जब "विश्लेषण" कहा जाता है, नई फ़ाइल है बनाया जाना है, जैसा कि आप देख सकते हैं, मैं समझ गया कि नक्शा को कम मुश्किल है कई आउटपुट लिखने के लिए ???

मै मैड्रिडस अंतर्ज्ञान समझता हूं, और मेरा उदाहरण मैप्रिडस के लिए पूरी तरह उपयुक्त लगता है, लेकिन जब ऐसा करने की बात आती है, तो जाहिर है, मुझे पर्याप्त जानकारी नहीं है और मैं स्टक हूं!

कृपया मदद करें।

Answer 1

आप केवल एक खाली reducer का उपयोग कर सकते हैं, और प्रति फ़ाइल एक एकल मैपर चलाने के लिए अपने काम का विभाजन कर सकते हैं। प्रत्येक मैपर आपके आउटपुट फ़ोल्डर में अपनी आउटपुट फाइल बना देगा।

Answer 2

नक्शा कम करना कुछ अच्छी जावा 6 समवर्ती विशेषताओं, विशेष रूप से भविष्य, कॉल करने योग्य और निष्पादक सेवा का उपयोग करके आसानी से कार्यान्वित किया जाता है।

मैं एक प्रतिदेय है कि रास्ते में एक फाइल का विश्लेषण करेगा बनाया आपके द्वारा निर्दिष्ट

public class FileAnalyser implements Callable<String> { 

    private Scanner scanner; 
    private List<String> termList; 

    public FileAnalyser(String filename, List<String> termList) throws FileNotFoundException { 
    this.termList = termList; 
    scanner = new Scanner(new File(filename)); 
    } 

    @Override 
    public String call() throws Exception { 
    StringBuilder buffer = new StringBuilder(); 
    while (scanner.hasNextLine()) { 
     String line = scanner.nextLine(); 
     String[] tokens = line.split(" "); 
     if ((tokens.length >= 3) && (inTermList(tokens[2]))) 
     buffer.append(line); 
    } 
    return buffer.toString(); 
    } 

    private boolean inTermList(String term) { 
    return termList.contains(term); 
    } 
} 

हमने पाया प्रत्येक फ़ाइल के लिए एक नया प्रतिदेय बना सकते हैं और प्रबंधक सेवा को यह भेजना आवश्यक है। सबमिशन का परिणाम एक भविष्य है जिसे हम फ़ाइल पार्स के परिणाम प्राप्त करने के लिए बाद में उपयोग कर सकते हैं।

public class Analayser { 

    private static final int THREAD_COUNT = 10; 

    public static void main(String[] args) { 

    //All callables will be submitted to this executor service 
    //Play around with THREAD_COUNT for optimum performance 
    ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT); 

    //Store all futures in this list so we can refer to them easily 
    List<Future<String>> futureList = new ArrayList<Future<String>>(); 

    //Some random term list, I don't know what you're using. 
    List<String> termList = new ArrayList<String>(); 
    termList.add("terma"); 
    termList.add("termb"); 

    //For each file you find, create a new FileAnalyser callable and submit 
    //this to the executor service. Add the future to the list 
    //so we can check back on the result later 
    for each filename in all files { 
     try { 
     Callable<String> worker = new FileAnalyser(filename, termList); 
     Future<String> future = executor.submit(worker); 
     futureList.add(future); 
     } 
     catch (FileNotFoundException fnfe) { 
     //If the file doesn't exist at this point we can probably ignore, 
     //but I'll leave that for you to decide. 
     System.err.println("Unable to create future for " + filename); 
     fnfe.printStackTrace(System.err); 
     } 
    } 

    //You may want to wait at this point, until all threads have finished 
    //You could maybe loop through each future until allDone() holds true 
    //for each of them. 

    //Loop over all finished futures and do something with the result 
    //from each 
    for (Future<String> current : futureList) { 
     String result = current.get(); 
     //Do something with the result from this future 
    } 
    } 
} 

मेरा उदाहरण यहां से पूर्ण, और कुशल से बहुत दूर है। मैं, नमूने का आकार नहीं माना जाता है, यदि यह वास्तव में बहुत बड़ा आप तत्वों है कि समाप्त कर दिया है को हटाने futureList से अधिक पाशन रख सकता है, है करने के लिए कुछ इसी तरह:

while (futureList.size() > 0) { 
     for (Future<String> current : futureList) { 
     if (current.isDone()) { 
      String result = current.get(); 
      //Do something with result 
      futureList.remove(current); 
      break; //We have modified the list during iteration, best break out of for-loop 
     } 
     } 
} 

वैकल्पिक रूप से आप एक निर्माता-उपभोक्त प्रकार सेटअप लागू कर सकता है, जहां निर्माता निष्पादक सेवा के लिए कॉलबेल प्रस्तुत करता है और भविष्य का उत्पादन करता है और उपभोक्ता भविष्य का परिणाम लेता है और भविष्य में त्याग देता है।

यह शायद उपज और उपभोक्ता को थ्रेड स्वयं की आवश्यकता होगी, और वायदा जोड़ने/हटाने के लिए एक सिंक्रनाइज़ सूची होगी।

कोई प्रश्न पूछें कृपया पूछें।