MapReduce - Combiners

Un combinatore, noto anche come semi-reducer, è una classe facoltativa che funziona accettando gli input dalla classe Map e successivamente passando le coppie chiave-valore di output alla classe Reducer.

La funzione principale di un Combiner è riepilogare i record di output della mappa con la stessa chiave. L'output (raccolta valore-chiave) del combinatore verrà inviato tramite la rete all'attività effettiva di Reducer come input.

Combiner

La classe Combiner viene utilizzata tra la classe Map e la classe Reduce per ridurre il volume di trasferimento dei dati tra Map e Reduce. Di solito, l'output dell'attività di mappa è grande e i dati trasferiti all'attività di riduzione sono elevati.

Il seguente diagramma delle attività di MapReduce mostra la FASE COMBINER.

Come funziona Combiner?

Ecco un breve riassunto su come funziona MapReduce Combiner:

Un combinatore non ha un'interfaccia predefinita e deve implementare il metodo reduce () dell'interfaccia Reducer.
Un combinatore opera su ogni tasto di output della mappa. Deve avere gli stessi tipi di valore-chiave di output della classe Reducer.
Un combinatore può produrre informazioni di riepilogo da un insieme di dati di grandi dimensioni perché sostituisce l'output della mappa originale.

Sebbene Combiner sia facoltativo, tuttavia aiuta a separare i dati in più gruppi per la fase di riduzione, che ne semplifica l'elaborazione.

Implementazione di MapReduce Combiner

L'esempio seguente fornisce un'idea teorica sui combinatori. Supponiamo di avere il seguente file di testo di input denominatoinput.txt per MapReduce.

What do you mean by Object
What do you know about Java
What is Java Virtual Machine
How Java enabled High Performance

Le fasi importanti del programma MapReduce con Combiner sono discusse di seguito.

Record Reader

Questa è la prima fase di MapReduce in cui il lettore di record legge ogni riga del file di testo di input come testo e restituisce l'output come coppie chiave-valore.

Input - Testo riga per riga dal file di input.

Output- Forma le coppie chiave-valore. Di seguito è riportato l'insieme delle coppie chiave-valore previste.

<1, What do you mean by Object>
<2, What do you know about Java>
<3, What is Java Virtual Machine>
<4, How Java enabled High Performance>

Fase della mappa

La fase Mappa prende l'input dal lettore di record, lo elabora e produce l'output come un altro insieme di coppie chiave-valore.

Input - La seguente coppia chiave-valore è l'input preso dal lettore di record.

<1, What do you mean by Object>
<2, What do you know about Java>
<3, What is Java Virtual Machine>
<4, How Java enabled High Performance>

La fase Mappa legge ogni coppia chiave-valore, divide ogni parola dal valore utilizzando StringTokenizer, tratta ogni parola come chiave e il conteggio di quella parola come valore. Il frammento di codice seguente mostra la classe Mapper e la funzione map.

public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable>
{
   private final static IntWritable one = new IntWritable(1);
   private Text word = new Text();
   
   public void map(Object key, Text value, Context context) throws IOException, InterruptedException 
   {
      StringTokenizer itr = new StringTokenizer(value.toString());
      while (itr.hasMoreTokens()) 
      {
         word.set(itr.nextToken());
         context.write(word, one);
      }
   }
}

Output - L'output previsto è il seguente:

<What,1> <do,1> <you,1> <mean,1> <by,1> <Object,1>
<What,1> <do,1> <you,1> <know,1> <about,1> <Java,1>
<What,1> <is,1> <Java,1> <Virtual,1> <Machine,1>
<How,1> <Java,1> <enabled,1> <High,1> <Performance,1>

Fase Combinatore

La fase Combiner prende ogni coppia chiave-valore dalla fase Map, la elabora e produce l'output come key-value collection coppie.

Input - La seguente coppia chiave-valore è l'input preso dalla fase Mappa.

<What,1> <do,1> <you,1> <mean,1> <by,1> <Object,1>
<What,1> <do,1> <you,1> <know,1> <about,1> <Java,1>
<What,1> <is,1> <Java,1> <Virtual,1> <Machine,1>
<How,1> <Java,1> <enabled,1> <High,1> <Performance,1>

La fase Combiner legge ogni coppia chiave-valore, combina le parole comuni come chiave e i valori come raccolta. Di solito, il codice e il funzionamento di un Combiner sono simili a quelli di un Reducer. Di seguito è riportato lo snippet di codice per la dichiarazione delle classi Mapper, Combiner e Reducer.

job.setMapperClass(TokenizerMapper.class);
job.setCombinerClass(IntSumReducer.class);
job.setReducerClass(IntSumReducer.class);

Output - L'output previsto è il seguente:

<What,1,1,1> <do,1,1> <you,1,1> <mean,1> <by,1> <Object,1>
<know,1> <about,1> <Java,1,1,1>
<is,1> <Virtual,1> <Machine,1>
<How,1> <enabled,1> <High,1> <Performance,1>

Fase riduttrice

La fase Reducer prende ogni coppia di raccolta chiave-valore dalla fase Combiner, la elabora e trasmette l'output come coppie chiave-valore. Notare che la funzionalità Combiner è la stessa del Reducer.

Input - La seguente coppia chiave-valore è l'input preso dalla fase Combiner.

<What,1,1,1> <do,1,1> <you,1,1> <mean,1> <by,1> <Object,1>
<know,1> <about,1> <Java,1,1,1>
<is,1> <Virtual,1> <Machine,1>
<How,1> <enabled,1> <High,1> <Performance,1>

La fase Riduttore legge ogni coppia chiave-valore. Di seguito è riportato lo snippet di codice per Combiner.

public static class IntSumReducer extends Reducer<Text,IntWritable,Text,IntWritable> 
{
   private IntWritable result = new IntWritable();
   
   public void reduce(Text key, Iterable<IntWritable> values,Context context) throws IOException, InterruptedException 
   {
      int sum = 0;
      for (IntWritable val : values) 
      {
         sum += val.get();
      }
      result.set(sum);
      context.write(key, result);
   }
}

Output - L'uscita attesa dalla fase Riduttore è la seguente:

<What,3> <do,2> <you,2> <mean,1> <by,1> <Object,1>
<know,1> <about,1> <Java,3>
<is,1> <Virtual,1> <Machine,1>
<How,1> <enabled,1> <High,1> <Performance,1>

Record Writer

Questa è l'ultima fase di MapReduce in cui Record Writer scrive ogni coppia chiave-valore dalla fase Reducer e invia l'output come testo.

Input - Ogni coppia chiave-valore della fase Riduttore insieme al formato di output.

Output- Fornisce le coppie chiave-valore in formato testo. Di seguito è riportato l'output previsto.

What           3
do             2
you            2
mean           1
by             1
Object         1
know           1
about          1
Java           3
is             1
Virtual        1
Machine        1
How            1
enabled        1
High           1
Performance    1

Programma di esempio

Il seguente blocco di codice conta il numero di parole in un programma.

import java.io.IOException;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;

import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class WordCount {
   public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable>
   {
      private final static IntWritable one = new IntWritable(1);
      private Text word = new Text();
      
      public void map(Object key, Text value, Context context) throws IOException, InterruptedException 
      {
         StringTokenizer itr = new StringTokenizer(value.toString());
         while (itr.hasMoreTokens()) 
         {
            word.set(itr.nextToken());
            context.write(word, one);
         }
      }
   }
   
   public static class IntSumReducer extends Reducer<Text,IntWritable,Text,IntWritable> 
   {
      private IntWritable result = new IntWritable();
      public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException 
      {
         int sum = 0;
         for (IntWritable val : values) 
         {
            sum += val.get();
         }
         result.set(sum);
         context.write(key, result);
      }
   }
   
   public static void main(String[] args) throws Exception 
   {
      Configuration conf = new Configuration();
      Job job = Job.getInstance(conf, "word count");
		
      job.setJarByClass(WordCount.class);
      job.setMapperClass(TokenizerMapper.class);
      job.setCombinerClass(IntSumReducer.class);
      job.setReducerClass(IntSumReducer.class);
		
      job.setOutputKeyClass(Text.class);
      job.setOutputValueClass(IntWritable.class);
		
      FileInputFormat.addInputPath(job, new Path(args[0]));
      FileOutputFormat.setOutputPath(job, new Path(args[1]));
		
      System.exit(job.waitForCompletion(true) ? 0 : 1);
   }
}

Salva il programma sopra come WordCount.java. Di seguito viene fornita la compilazione e l'esecuzione del programma.

Compilazione ed esecuzione

Supponiamo di essere nella directory home dell'utente Hadoop (ad esempio, / home / hadoop).

Seguire i passaggi indicati di seguito per compilare ed eseguire il programma sopra.

Step 1 - Utilizzare il seguente comando per creare una directory in cui memorizzare le classi java compilate.

$ mkdir units

Step 2- Scarica Hadoop-core-1.2.1.jar, che viene utilizzato per compilare ed eseguire il programma MapReduce. Puoi scaricare il jar da mvnrepository.com .

Supponiamo che la cartella scaricata sia / home / hadoop /.

Step 3 - Utilizza i seguenti comandi per compilare il file WordCount.java programma e per creare un vaso per il programma.

$ javac -classpath hadoop-core-1.2.1.jar -d units WordCount.java
$ jar -cvf units.jar -C units/ .

Step 4 - Utilizzare il comando seguente per creare una directory di input in HDFS.

$HADOOP_HOME/bin/hadoop fs -mkdir input_dir

Step 5 - Utilizzare il seguente comando per copiare il file di input denominato input.txt nella directory di input di HDFS.

$HADOOP_HOME/bin/hadoop fs -put /home/hadoop/input.txt input_dir

Step 6 - Utilizzare il seguente comando per verificare i file nella directory di input.

$HADOOP_HOME/bin/hadoop fs -ls input_dir/

Step 7 - Utilizzare il comando seguente per eseguire l'applicazione di conteggio parole prendendo i file di input dalla directory di input.

$HADOOP_HOME/bin/hadoop jar units.jar hadoop.ProcessUnits input_dir output_dir

Attendi qualche istante finché il file non viene eseguito. Dopo l'esecuzione, l'output contiene una serie di suddivisioni di input, attività di mappa e attività di riduzione.

Step 8 - Utilizzare il seguente comando per verificare i file risultanti nella cartella di output.

$HADOOP_HOME/bin/hadoop fs -ls output_dir/

Step 9 - Usa il seguente comando per vedere l'output in Part-00000file. Questo file è generato da HDFS.

$HADOOP_HOME/bin/hadoop fs -cat output_dir/part-00000

Di seguito è riportato l'output generato dal programma MapReduce.

What           3
do             2
you            2
mean           1
by             1
Object         1
know           1
about          1
Java           3
is             1
Virtual        1
Machine        1
How            1
enabled        1
High           1
Performance    1

↰ Previous page Next page ↱