精华内容
下载资源
问答
  • mapreduce倒排索引
    2018-06-09 21:15:31

        倒排索引就是某个单词在那些文件中出现的次数,而在最开始学习的Wordcount中是某个文件中那些单词出现的次数,两者正好相反,就像在搜索引擎上搜索一个单词,下面就会罗列出这个单词在哪些文件里出现过。

        首先我们就要想好,什么是key,什么是value,map输出的结果是什么,reduce怎样处理才能够得到想要的结果。

        在倒排索引中,我们需要得到单词-文件名-次数,因为这个次数是这个单词在这个文件中出现的次数,所以此时单词和文件应该合在一起作为key,次数作为value。 但一次reduce过后还需要将结果中单词合并。因为我们最后要的结果是单词-文件名~次数,文件名~次数······所以需要两次reduce,就用到了combiner 。

        此时就变得清晰了,第一次map要输出单词和文件名共同为键,用combiner计算出次数,combiner再输出单词和文件名-次数,用reduce进行合并。combine就相当于一次reducer,但combiner在map端。

    package mr.inverseIndex;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.LongWritable;
    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.input.FileSplit;
    import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
    
    import java.io.IOException;
    import java.net.URI;
    import java.net.URISyntaxException;
    
    public class ForInverseMR {
        public static class ForMapper extends Mapper<LongWritable,Text,Text,Text>{
            private Text oKey=new Text();
            private Text oValue=new Text();
            @Override
            protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
                String filename=((FileSplit)context.getInputSplit()).getPath().getName();//获得文件名
                String strs[]=value.toString().split(" ");
                for(String s:strs){   //遍历单词
                    oKey.set(s+"-"+filename);//将单词和文件名设置为键    
                    context.write(oKey,oValue);//value为空,为了计数
                }
                //输出键值对格式 单词-文件名
            }
        }
    
        public static class ForCombiner extends Reducer<Text,Text,Text,Text>{
            private Text oKey=new Text();
            private Text oValue=new Text();
            @Override
            protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
                int count=0;//次数
                for (Text text:values){
                    count++;
                }
                String strs[]=key.toString().split("-");//将键重新拆分为单词
                oKey.set(strs[0]);
                oValue.set(strs[1]+"~"+count);
                context.write(oKey,oValue);
                //输出键值对格式 单词1 文件名1~次数
                //              单词1 文件名2~次数
            }
        }
    
        public static class ForReducer extends Reducer<Text,Text,Text,Text>{
            private Text oValue=new Text();
            @Override
            protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
                StringBuilder sb=new StringBuilder();
                for(Text text:values){
                    sb.append(text.toString()).append(",");
                }
                sb.delete(sb.length()-1,sb.length());//去掉最后一个逗号
                oValue.set(sb.toString());
                context.write(key,oValue);
                //输出格式 单词 文件1~次数,文件2~次数···
            }
        }
    
        public static void main(String[] args) throws IOException, URISyntaxException, ClassNotFoundException, InterruptedException {
            Job job= Job.getInstance();
            // 设置map的类
            job.setMapperClass(ForInverseMR.ForMapper.class);
            //设置combiner的类
            job.setCombinerClass(ForInverseMR.ForCombiner.class);
            //设置reduce的类
            job.setReducerClass(ForInverseMR.ForReducer.class);
    
            //设置map的输出key value 类型
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(Text.class);
            // 设置reduce 输出的key value 类型
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(Text.class);
    
            //设置输入文件的路径
            FileInputFormat.addInputPath(job,new Path("F:\\forTestData\\inverseIndex\\data"));
            //设置输出文件的路径//如果重复文件夹就删
            FileSystem fs=FileSystem.get(new URI("file://F://out"),new Configuration());
            if(fs.exists(new Path("F://out"))){
                fs.delete(new Path("F://out"),true);
            }
            FileOutputFormat.setOutputPath(job,new Path("F://out"));
    
            //保证reduce的个数是1
            job.setNumReduceTasks(1);
            //true表示将运行进度等信息及时输出给用户,false的话只是等待作业结束
            job.waitForCompletion(true);
        }
    }

        完成。

     

     

    更多相关内容
  • MapReduce倒排索引代码

    2019-03-14 19:17:16
    倒排索引源于实际应用中需要根据属性的值来查找记录。这种索引表中的每一项都包括一个属性值和具有该属性值的各记录的地址。由于不是由记录来确定属性值,而是由属性值来确定记录的位置,因而称为倒排索引(inverted ...
  • MapReduce倒排索引建立 求某些单词在文章中出现多少次 有三个文档的内容,求hello,tom,jerry三个单词在其中各出现多少次 hello tom hello jerry hello tom hello jerry hello jerry tom jerry hello jerry ...

    MapReduce倒排索引建立


    求某些单词在文章中出现多少次

    • 有三个文档的内容,求hello,tom,jerry三个单词在其中各出现多少次
    hello tom
    hello jerry
    hello tom
    
    hello jerry
    hello jerry
    tom jerry
    
    hello jerry
    hello tom
    
    • java代码实现

    定义一个Mapper类

    package cn.itcast.demo2;
    
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.LongWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.InputSplit;
    import org.apache.hadoop.mapreduce.Mapper;
    import org.apache.hadoop.mapreduce.lib.input.FileSplit;
    
    import java.io.IOException;
    
    public class IndexMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            //获取文件切片,强转!强转!
            FileSplit fileSplit = (FileSplit) context.getInputSplit();
            //获取文档名字
            String name = fileSplit.getPath().getName();
            //对v1进行切割
            String[] split = value.toString().split(" ");
            for (String s : split) {
                context.write(new Text(s + "-" + name), new IntWritable(1));
            }
        }
    }
    

    定义一个reducer类

    package cn.itcast.demo2;
    
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.Reducer;
    
    import java.io.IOException;
    
    public class IndexReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
            int i = 0;
            for (IntWritable value : values) {
                //获取单词出现的次数
                i += value.get();
            }
            context.write(key, new IntWritable(i));
        }
    }
    

    程序main函数入口

    package cn.itcast.demo2;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.conf.Configured;
    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.lib.input.TextInputFormat;
    import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
    import org.apache.hadoop.util.Tool;
    import org.apache.hadoop.util.ToolRunner;
    
    public class IndexMain extends Configured implements Tool {
        @Override
        public int run(String[] args) throws Exception {
            //获取job对象
            Job job = Job.getInstance(super.getConf(), "getIndex");
            //输入数据,设置输入路径
            job.setInputFormatClass(TextInputFormat.class);
            TextInputFormat.setInputPaths(job, new Path("file:Volumes/赵壮备份/大数据离线课程资料/5.大数据离线第五天/倒排索引/input"));
    
            //自定义map逻辑
            job.setMapperClass(IndexMapper.class);
            //设置k2,v2输出类型
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(IntWritable.class);
    
            //自定义reduce逻辑
            job.setReducerClass(IndexReducer.class);
            //设置k3,v3输出类型
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
    
            //输出数据,设置输出路径
            job.setOutputFormatClass(TextOutputFormat.class);
            TextOutputFormat.setOutputPath(job, new Path("file:Volumes/赵壮备份/大数据离线课程资料/5.大数据离线第五天/倒排索引/output"));
    
            //提交任务到集群
            boolean b = job.waitForCompletion(true);
            return b ? 0 : 1;
        }
    
        public static void main(String[] args) throws Exception {
            int run = ToolRunner.run(new Configuration(), new IndexMain(), args);
            System.exit(run);
        }
    }
    

    输出结果

    hello-a.txt	3
    hello-b.txt	2
    hello-c.txt	2
    jerry-a.txt	1
    jerry-b.txt	3
    jerry-c.txt	1
    tom-a.txt	2
    tom-b.txt	1
    tom-c.txt	1
    
    展开全文
  • MapReduce倒排索引

    千次阅读 2021-06-17 09:41:11
    MapReduce倒排索引一、相关说明二、测试数据三、编程思路四、实现步骤五、打包上传到集群中运行(仅供参考,自行修改) 一、相关说明 倒排列表概念 : 倒排列表用来记录有哪些文档包含了某个单词。一般在文档...

    一、相关说明


    • 倒排列表概念

      倒排列表用来记录有哪些文档包含了某个单词。一般在文档集合里会有很多文档包含某个单词,每个文档会记录文档编号(DocID),单词在这个文档中出现的次数(TF)及单词在文档中哪些位置出现过等信息,这样与一个文档相关的信息被称做倒排索引项(Posting),包含这个单词的一系列倒排索引项形成了列表结构,这就是某个单词对应的倒排列表。图1是倒排列表的示意图,在文档集合中出现过的所有单词及其对应的倒排列表组成了倒排索引。
      在这里插入图片描述
      在实际的搜索引擎系统中,并不存储倒排索引项中的实际文档编号,而是代之以文档编号差值(D-Gap)。文档编号差值是倒排列表中相邻的两个倒排索引项文档编号的差值,一般在索引构建过程中,可以保证倒排列表中后面出现的文档编号大于之前出现的文档编号,所以文档编号差值总是大于0的整数。如图2所示的例子中,原始的 3个文档编号分别是187、196和199,通过编号差值计算,在实际存储的时候就转化成了:187、9、3。
      之所以要对文档编号进行差值计算,主要原因是为了更好地对数据进行压缩,原始文档编号一般都是大数值,通过差值计算,就有效地将大数值转换为了小数值,而这有助于增加数据的压缩率。
      在这里插入图片描述

    • 倒排索引概念

      倒排索引(英语:Inverted index),也常被称为反向索引、置入档案或反向档案,是一种索引方法,被用来存储在全文搜索下某个单词在一个文档或者一组文档中的存储位置的映射。它是文档检索系统中最常用的数据结构。通过倒排索引,可以根据单词快速获取包含这个单词的文档列表。倒排索引主要由两个部分组成:“单词词典”和“倒排文件”。
      倒排索引有两种不同的反向索引形式:
      一条记录的水平反向索引(或者反向档案索引)包含每个引用单词的文档的列表。
      一个单词的水平反向索引(或者完全反向索引)又包含每个单词在一个文档中的位置。
      后者的形式提供了更多的兼容性(比如短语搜索),但是需要更多的时间和空间来创建。
      现代搜索引擎的索引都是基于倒排索引。相比“签名文件”、“后缀树”等索引结构,“倒排索引”是实现单词到文档映射关系的最佳实现方式和最有效的索引结构。
      在这里插入图片描述

    • 要求:求出每个单词在各个文档中出现的次数及所在文档,结果如下。

    二、测试数据


    1. 测试数据如下
      1)文件一:data01.txt,内容如下:

      I love Beijing
      

      2)文件二:data02.txt,内容如下:

      I love China
      

      3)文件三:data03.txt,内容如下:

      Beijing is the capital of China
      
    • 将三个文件放置在相同的目录下

    三、编程思路


    • 思路
      1、按照wordcount的思路,添加一个combiner对数据先做一次处理
      2、保持kev/value对数据类型一致

    四、实现步骤


    1. 在Idea或eclipse中创建maven项目

    2. 在pom.xml中添加hadoop依赖

      <dependency>
      	<groupId>org.apache.hadoop</groupId>
      	<artifactId>hadoop-common</artifactId>
      	<version>2.7.3</version>
      </dependency>
      <dependency>
      	<groupId>org.apache.hadoop</groupId>
      	<artifactId>hadoop-hdfs</artifactId>
      	<version>2.7.3</version>
      </dependency>
      <dependency>
      	<groupId>org.apache.hadoop</groupId>
      	<artifactId>hadoop-mapreduce-client-common</artifactId>
      	<version>2.7.3</version>
      </dependency>
      <dependency>
      	<groupId>org.apache.hadoop</groupId>
      	<artifactId>hadoop-mapreduce-client-core</artifactId>
      	<version>2.7.3</version>
      </dependency>
      
    3. 添加log4j.properties文件在资源目录下即resources,文件内容如下:

      ### 配置根 ###
      log4j.rootLogger = debug,console,fileAppender
      ## 配置输出到控制台 ###
      log4j.appender.console = org.apache.log4j.ConsoleAppender
      log4j.appender.console.Target = System.out
      log4j.appender.console.layout = org.apache.log4j.PatternLayout
      log4j.appender.console.layout.ConversionPattern = %d{ABSOLUTE} %5p %c:%L - %m%n
      ### 配置输出到文件 ###
      log4j.appender.fileAppender = org.apache.log4j.FileAppender
      log4j.appender.fileAppender.File = logs/logs.log
      log4j.appender.fileAppender.Append = false
      log4j.appender.fileAppender.Threshold = DEBUG,INFO,WARN,ERROR
      log4j.appender.fileAppender.layout = org.apache.log4j.PatternLayout
      log4j.appender.fileAppender.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
      
    4. 编写文本类型的mapper即InvertedIndexMapper

      import java.io.IOException;
      import org.apache.hadoop.io.LongWritable;
      import org.apache.hadoop.io.Text;
      import org.apache.hadoop.mapreduce.Mapper;
      import org.apache.hadoop.mapreduce.lib.input.FileSplit;
      
      public class RevertedIndexMapper extends Mapper<LongWritable, Text, Text, Text> {
      
      @Override
      protected void map(LongWritable key1, Text value1, Context context)
      throws IOException, InterruptedException {
      		// 数据:I love Beijing and love Shanghai
      		//得到数据来自哪个文件??? /mydata/data01.txt
      		String path = ((FileSplit)context.getInputSplit()).getPath().toString();
      		//得到文件名
      		//最后一个斜线
      		int index = path.lastIndexOf("/");
      		//文件名
      		String fileName = path.substring(index + 1);
      		
      		//分词
      		String[] words = value1.toString().split(" ");
      		for(String w:words){
      		//格式: 单词:文件名
      		context.write(new Text(w+":"+fileName), new Text("1"));
      		}
      	}
      }
      
    5. 编写Combiner,先做一次合并操作

      import java.io.IOException;
      import org.apache.hadoop.io.Text;
      import org.apache.hadoop.mapreduce.Reducer;
      
      public class RevertedIndexCombiner extends Reducer<Text, Text, Text, Text> {
      
      	@Override
      	protected void reduce(Text k21, Iterable<Text> v21, Context context)
      	throws IOException, InterruptedException {
      		// 求和:对同一个文件中,每个单词的频率求和
      		int total = 0;
      		for(Text v:v21){
      			total = total + Integer.parseInt(v.toString());
      		}
      		
      		//输出
      		//分离:单词和文件名 k21: love:data01.txt
      		String data = k21.toString();
      		//找到冒号的位置
      		int index = data.indexOf(":");
      		
      		String word = data.substring(0, index); //单词
      		String fileName = data.substring(index+1);//文件名
      		
      		//输出
      		context.write(new Text(word), new Text(fileName+":"+total));
      	}
      }
      
    6. 编写reducer类

      import java.io.IOException;
      
      import org.apache.hadoop.io.Text;
      import org.apache.hadoop.mapreduce.Reducer;
      
      public class RevertedIndexReducer extends Reducer<Text, Text, Text, Text> {
      
      	@Override
      	protected void reduce(Text k3, Iterable<Text> v3, Context context)
      	throws IOException, InterruptedException {
      		//对combiner的输出的value 拼加
      		String str = "";
      		for(Text t:v3){
      			str = "(" + t.toString()+")" + str;
      		}
      		context.write(k3, new Text(str));
      	}
      
      }
      
    7. 编写Driver类

      import java.io.IOException;
      
      import org.apache.hadoop.conf.Configuration;
      import org.apache.hadoop.fs.Path;
      import org.apache.hadoop.io.DoubleWritable;
      import org.apache.hadoop.io.IntWritable;
      import org.apache.hadoop.io.Text;
      import org.apache.hadoop.mapreduce.Job;
      import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
      import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
      
      public class RevertedIndexMain {
      
      	public static void main(String[] args) throws Exception {
      		// 创建一个job和任务入口
      		Job job = Job.getInstance(new Configuration());
      		job.setJarByClass(RevertedIndexMain.class); //main方法所在的class
      		
      		//指定job的mapper和输出的类型<k2 v2>
      		job.setMapperClass(RevertedIndexMapper.class);
      		job.setMapOutputKeyClass(Text.class); //k2的类型
      		job.setMapOutputValueClass(Text.class); //v2的类型
      		
      		//引入combiner
      		job.setCombinerClass(RevertedIndexCombiner.class);
      		
      		//指定job的reducer和输出的类型<k4 v4>
      		job.setReducerClass(RevertedIndexReducer.class);
      		job.setOutputKeyClass(Text.class); //k4的类型
      		job.setOutputValueClass(Text.class); //v4的类型
      		
      		//指定job的输入和输出
      		FileInputFormat.setInputPaths(job, new Path("F:\\NIIT\\hadoopOnWindow\\input\\invertedindex"));
      		FileOutputFormat.setOutputPath(job, new Path("F:\\NIIT\\hadoopOnWindow\\input\\invertedindex\\out"));
      		
      		//执行job
      		job.waitForCompletion(true);
      	}
      }
      
    8. 本地运行代码,测试下结果正确与否,结果如下:
      在这里插入图片描述

    五、打包上传到集群中运行(仅供参考,自行修改)


    1. 本地运行测试结果正确后,需要对Driver类输出部分代码进行修改,具体修改如下:
      FileOutputFormat.setOutputPath(job,new Path(args[0]));

    2. 修改Job中【数据库】相关的信息

    3. 将程序打成jar包,需要在pom.xml中配置打包插件

      <build>
              <plugins>
                  <plugin>
                      <groupId>org.apache.maven.plugins</groupId>
                      <artifactId> maven-assembly-plugin </artifactId>
                      <configuration>
                          <!-- 使用Maven预配置的描述符-->
                          <descriptorRefs>
                              <descriptorRef>jar-with-dependencies</descriptorRef>
                          </descriptorRefs>
                      </configuration>
                      <executions>
                          <execution>
                              <id>make-assembly</id>
                              <!-- 绑定到package生命周期 -->
                              <phase>package</phase>
                              <goals>
                                  <!-- 只运行一次 -->
                                  <goal>single</goal>
                              </goals>
                          </execution>
                      </executions>
                  </plugin>
              </plugins>
          </build>
      

      按照如下图所示进行操作
      在这里插入图片描述
      在这里插入图片描述

    4. 提交集群运行,执行如下命令:

      hadoop jar packagedemo-1.0-SNAPSHOT.jar  com.niit.mr.EmpJob /datas/emp.csv /output/emp/ 
      

      至此,所有的步骤已经完成,大家可以试试,祝大家好运~~~~

    展开全文
  • mapreduce 倒排索引

    2019-04-30 16:04:44
    日萌社 人工智能AI:Keras PyTorch MXNet TensorFlow PaddlePaddle...每个各自的mapreduce中的相同顺序的分区中的数据都传到同一个reducetask中进行全局合并:key=单词。value=文件名:次数N;文件名:次数N;文件名:次数N

    日萌社

    人工智能AI:Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战(不定时更新)


    代码下载链接:

    https://pan.baidu.com/s/1VhxRXB63vz_4QZyKVFqoZQ 
    提取码:2v0l 

    1.读取的文件中第一行数据:key=偏移量0。value=第一行内容
    2.经过了maptask:key=单词:文件名。value=次数1
    3.经过了局部合并combiner:key=单词。value=文件名:次数N
    4.每个各自的mapreduce中的相同顺序的分区中的数据都传到同一个reducetask中进行全局合并:key=单词。value=文件名:次数N;文件名:次数N;文件名:次数N
    

     

    展开全文
  • hadoop–MapReduce倒排索引 1.倒排索引介绍 倒排索引是文档检索系统中最常用的数据结构,被广泛应用于全文搜索引擎。倒排索引主要用来存储某个单词(或词组)在一组文档中的存储位置的映射,提供了可以根据内容来...
  • 2)第一次处理,编写OneIndexReducer类。(2)第二次处理,编写TwoIndexReducer类。(1)第一次处理,编写OneIndexMapper类。(3)第一次处理,编写...有大量的文本(文档、网页),需要建立搜索索引。...
  • MR实现倒排索引
  • MapReduce实现倒排索引

    2020-11-29 23:44:42
    MapReduce实现倒排索引 配置过程 在实验室机器上进行的相关配置:系统本身就是Ubuntu18.04,需要安装Hadoop 3.0.3版本,需要配置Jdk是1.8。 SSH的配置 cd ~/.ssh cat id_rsa.pub >> authorized_keys ssh ...
  • 倒排索引主要用来存储某个单词(或词组)在一组文档中的存储位置的映射,提供了可以根据内容来查找文档的方式,而不是根据文档来确定内容,因此称为倒排索引(Inverted Index)。带有倒排索引的文件我们称为
  • package MapReducer05; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io....import org.apache.hadoop.mapreduce.Job; import org.apache.hadoop.ma...
  • TextInputFormat是mapreduce程序中内置的一种读取数据组件 准确的说 叫做 读取文本文件的输入组件 job.setInputFormatClass(TextInputFormat. class ); job.setOutputFormatClass(TextOutputFormat. class ); ...
  • import org.apache.hadoop.mapreduce.Mapper; import org.apache.hadoop.mapreduce.lib.input.FileSplit; import java.io.IOException; public class Map extends Mapper, Text, Text, Text> { String name; //...
  • 倒排索引主要用来存储某个单词(或词组)住一组文档中的存储位置的映射,提供了可以根据内容来查找文档的方式,而不是根据文档来确定内容,因此称为倒排索引(Inverted Index)。带有倒排索引的文件称为倒排索引文件,...
  • 原理"倒排索引"是文档检索系统中最常用的数据结构,被广泛地应用于全文搜索引擎。它主要是用来存储某个单词(或词组)在一个文档或一组文档中的存储位置的映射,即提供了一种根据内容来查找文档的方式。由于不是根据...
  • mapreduce经典案例倒排索引
  • MapReduce倒排索引概要

    2015-11-10 22:50:54
    使用场景:主要用于索引,以提高搜索数据速度 例如百度搜索运行环境:windows下VM虚拟机,centos系统,hadoop2.2.0,三节点 ,java 1.7 需要处理的数据为 求出每个索引所对应的包含索引的网址package boke;import...
  • Hadoop:MapReduce倒排索引前言一、案例要求二、实现过程1.IntelliJ IDEA 创建Maven工程2.完整代码3.Maven打包4.Hadoop集群运行推荐Hadoop学习网站 前言 本案例有一定门槛,需要一点Java基础,Hadoop入门级知识,...
  • import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat; import org.apache.hadoop.util.GenericOptionsParser; import java.io.IOException; import java.util.StringTokenizer; /** * FileName: ...
  • 实现倒排索引效果:统计每个单词在不同文件中的出现次数;倒排索引的原理参考实验说明; 输入:自己编辑几个文件,例如 a.txt,b.txt,c.txt。每个文件的内容为若干行单词,单词之间以空格分开,并将这些文件上传到 ...
  • Hadoop mapreduce 实现InvertedIndexer倒排索引,能用。
  • MapReduce--倒排索引

    2018-06-07 17:02:19
    文档倒排算法简介Inverted Index(倒排索引)是目前几乎所有支持全文检索的搜索引擎都要依赖的一个数据结构。基于索引结构,给出一个词(term),能取得含有这个term的文档列表(the list of documents) Web Search中的...
  • 文档倒排索引MapReduce程序设计与实现
  • 下面先从一张图理解MapReduce得整个工作原理 下面对上面出现的一些名词进行介绍ResourceManager:是YARN资源控制框架的中心模块,负责集群中所有的资源的统一管理和分配。它接收来自NM(NodeManager)的汇报,建立AM,...
  • 倒排索引目录一、实验内容二、实验过程 一、实验内容 "倒排索引"是文档检索系统中最常用的数据结构,被广泛地应用于全文搜索引擎。它主要是用来存储某个单词(或词组)在一个文档或一组文档中的存储位置的映射,即...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,006
精华内容 2,402
关键字:

mapreduce倒排索引