"倒排索引"是文档检索系统中最常用的数据结构，被广泛地应用于全文搜索引擎。
它主要是用来存储某个单词（或词组）在一个文档或一组文档中的存储位置的映射，即提供了一种根据内容来查找文档的方式。
由于不是根据文档来确定文档所包含的内容，而是进行相反的操作，因而称为倒排索引（Inverted Index）。1 实例描述
通常情况下，倒排索引由一个单词（或词组）以及相关的文档列表组成，
文档列表中的文档或者是标识文档的ID号，或者是指文档所在位置的URL。
在实际应用中，还需要给每个文档添加一个权值，用来指出每个文档与搜索内容的相关度。
样例输入：
1）file1：
MapReduce is simple
2）file2：
MapReduce is powerful is simple
3）file3：
Hello MapReduce bye MapReduce
输出：
Hello | file3:1 |
MapReduce | file3:2 | file1:1 | file2:1 |
bye | file3:1 |
is | file1:1 | file2:2 |
powerful | file2:1 |
simple | file2:1 | file1:1 |2.实现步骤
a、map方法实现key=单词名：文件名 value=1，以便于combiner实现词频统计和单词名：文件名合并
b、combiner方法实现词频统计和相同名合并，key=单词名，value=文件名：词频，以便于reduce实现value追加
c、reduce方法实现value追加
1）Map过程
首先使用默认的TextInputFormat类对输入文件进行处理，得到文本中每行的偏移量及其内容。
显然，Map过程首先必须分析输入的<key,value>对，得到倒排索引中需要的三个信息：单词、文档URL和词频。
存在两个问题：
第一，<key,value>对只能有两个值，在不使用Hadoop自定义数据类型的情况下，
需要根据情况将其中两个值合并成一个值，作为key或value值；
第二，通过一个Reduce过程无法同时完成词频统计和生成文档列表，所以必须增加一个Combine过程完成词频统计。
单词和URL组成key值（如"MapReduce：file1.txt"），将词频作为value，
这样做的好处是可以利用MapReduce框架自带的Map端排序，将同一文档的相同单词的词频组成列表，
传递给Combine过程，实现类似于WordCount的功能。
2）Combine过程
经过map方法处理后，Combine过程将key值相同的value值累加，得到一个单词在文档在文档中的词频，
如果直接将输出作为Reduce过程的输入，在Shuffle过程时将面临一个问题：所有具有相同单词的记录
（由单词、URL和词频组成）应该交由同一个Reducer处理，但当前的key值无法保证这一点，所以必须修改key值和value值。
这次将单词作为key值，URL和词频组成value值（如"file1.txt：1"）。
可以利用MapReduce框架默认的HashPartitioner类完成Shuffle过程，将相同单词的所有记录发送给同一个Reducer进行处理。
3）Reduce过程
经过上述两个过程后，Reduce过程只需将相同key值的value值组合成倒排索引文件所需的格式即可，
剩下的事情就可以直接交给MapReduce框架进行处理了。
4）需要解决的问题
本倒排索引在文件数目上没有限制，但是单词文件不宜过大（具体值与默认HDFS块大小及相关配置有关），要保证每个文件对应一个split。
否则，由于Reduce过程没有进一步统计词频，最终结果可能会出现词频未统计完全的单词。
可以通过重写InputFormat类将每个文件为一个split，避免上述情况。
或者执行两次MapReduce，第一次MapReduce用于统计词频，第二次MapReduce用于生成倒排索引。
除此之外，还可以利用复合键值对等实现包含更多信息的倒排索引。实现代码：
package Inverted;
import java.io.IOException;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
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 org.apache.hadoop.util.GenericOptionsParser;
public class InvertedIndex {
static String INPUT_PATH = "hdfs://master:9000/c";
static String OUTPUT_PATH = "hdfs://master:9000/output";
static class Map extends Mapper<Object,Object,Text,Text>{
private Text keyInfo = new Text();
private Text valueInfo = new Text();
private FileSplit split;
//实现：key=单词名：所在文件名 value=1
protected void map(Object key, Object value, Context context) throws IOException, InterruptedException{
split = (FileSplit)context.getInputSplit();
StringTokenizer itr = new StringTokenizer(value.toString());
while(itr.hasMoreTokens()){
//获得file_name
int splitIndex = split.getPath().toString().indexOf("file");
//key--->word:file_name
keyInfo.set(itr.nextToken()+":"+split.getPath().toString().substring(splitIndex));
//value--->1
valueInfo.set("1");
System.out.println("keyInfo: "+keyInfo);
System.out.println("valueInfo: "+valueInfo);
context.write(keyInfo, valueInfo);
}
}
}
//实现词频统计+key=单词名，value=文件名：词频
static class Combine extends Reducer<Text,Text,Text,Text>{
private Text info = new Text();
protected void reduce(Text key, Iterable<Text> values, Context context)
throws IOException, InterruptedException{
//词频统计求和
int sum=0;
for(Text value:values){
sum+=Integer.parseInt(value.toString());
}
int splitIndex = key.toString().indexOf(":");
System.out.println("key: "+key);
System.out.println("splitIndex: "+splitIndex);
//key--->word value--->filename:sum
info.set(key.toString().substring(splitIndex+1)+":"+sum);
key.set(key.toString().substring(0, splitIndex));
context.write(key, info);
}
}
//实现相同key值，value值相追加
static class Reduce extends Reducer<Text,Text,Text,Text>{
private Text result = new Text();
protected void reduce(Text key, Iterable<Text> values, Context context)
throws IOException, InterruptedException{
String fileList = new String();
for(Text value:values){
fileList=fileList+" | "+value.toString();
}
fileList+=" |";
result.set(fileList);
context.write(key, result);
}
}
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
// TODO Auto-generated method stub
Path outputpath = new Path(OUTPUT_PATH);
Configuration conf = new Configuration();
FileSystem fs = outputpath.getFileSystem(conf);
if(fs.exists(outputpath)){
fs.delete(outputpath,true);
}
conf.set("fs.default.name ", "hdfs://master:9000/");
String[] ioArgs = new String[]{"index_in","index_out"};
String[] otherArgs = new GenericOptionsParser(conf,ioArgs).getRemainingArgs();
if(otherArgs.length!=2){
System.out.println("Usage:Inverted Index<in><out>");
}
Job job = Job.getInstance(conf);
job.setJarByClass(InvertedIndex.class);
job.setCombinerClass(Reduce.class);
FileInputFormat.setInputPaths(job, INPUT_PATH);
FileOutputFormat.setOutputPath(job, outputpath);
job.setMapperClass(Map.class);
//设置Combiner
job.setCombinerClass(Combine.class);
job.setReducerClass(Reduce.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(Text.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
job.waitForCompletion(true);
}
}TF-IDF
原理：在一个文件里，词频（Term Frequency）TF指某个词在文件中出现的次数。
这个数字通常会被正规化，防止它偏向长的文件（在长文件中比短文件有更高的词频，而不管该词是否重要）
IDF逆向文件频率是普遍重要度的度量。
IDF=Math.log10(总文件数/包含该词文件的数目)。
某一文件内的高词频，以及该词在整个文件集合中的低文件频率，可以产生出高权重的TF-IDF。
因此TF-IDF可以过滤掉常见的词语，保留重要的词语。
例子：
在一篇文件总词数100个，其中mapreduce出现3次，词频=0.03
测定mapreduce在1000份文件中出现过，文件总数10000000，IDF=log（10000000/1000）=4
最后 TF-IDF的分数=0.03*4=0.121 问题分析
job1 对每个文件集中每个输入文件，分别统计其各个单词出现次数，输出为
<单词w |文件名f , w在f中出现的次数 f-w-count>
job2 对job1的输出，统计文件f中所有单词的个数（及一共有多少个唯一的单词）
输出为 <单词w | 文件名f，w在f中出现次数 f-w-count | 文件f中单词数f-length>
job3 先统计文件集的文件个数length；
然后，根据job2的输出，统计每个单词在所有文件集中出现的文件个数，输出
1. <w,[f1=f1-w-count|f1-length, f2… ]>
2. <w|f1,f1-w-count|f1-length*log(length/k)>
即<单词 w|文件名f1, tf-idf-f1-w>也就是每个单词在文件中的权重TF-IDF。
统计文件集docs个数length
+使用log（length/f-contains-w）=IDF
+f-w-count/length得到TF2.示例代码
TF=wordCount/sumOfWordsInDoc
double tf=Double.valueOf(wordFrequencyAndTotalWords[0])/Double.valueOf(wordFrequencyAndTotalWords[1]);
double idf=(double)totalDocs/totalDocsForWrod;
double tfidf=tf*Math.log10(idf)
context.write(word|filename,tfidf) //计算某个文件某个单词的TF-IDF
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
