【Hadoop学习之十二】MapReduce案例分析四-TF-IDF

最新推荐文章于 2022-04-25 22:04:32 发布
最新推荐文章于 2022-04-25 22:04:32 发布
阅读量160 收藏
点赞数
文章标签： 大数据 java 运维
原文链接：http://www.cnblogs.com/cac2020/p/10312979.html
版权

环境
　　虚拟机：VMware 10
　　Linux版本：CentOS-6.5-x86_64
　　客户端：Xshell4
　　FTP：Xftp4
　　jdk8
　　hadoop-3.1.1

概念
TF-IDF（term frequency–inverse document frequency）是一种用于资讯检索与资讯探勘的常用加权技术。
TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。
　　·字词的重要性随着它在文件中出现的次数成正比增加
　　·但同时会随着它在语料库中出现的频率成反比下降
TF-IDF加权的各种形式常被搜寻引擎应用
　　·作为文件与用户查询之间相关程度的度量或评级。
　　·除了TF-IDF以外，因特网上的搜寻引擎还会使用基于链接分析的评级方法，以确定文件在搜寻结果中出现的顺序：PR。

词频 (term frequency, TF) 指的是某一个给定的词语在一份给定的文件中出现的次数。这个数字通常会被归一化（分子一般小于分母 区别于IDF），以防止它偏向长的文件。（同一个词语在长文件里可能会比短文件有更高的词频，而不管该词语重要与否。）
公式中：ni,j是该词在文件dj中的出现次数，而分母则是在文件dj中所有字词的出现次数之和。

逆向文件频率 (inverse document frequency, IDF) 是一个词语普遍重要性的度量。某一特定词语的IDF，可以由总文件数目除以包含该词语之文件的数目，再将得到的商取对数得到。
|D|：语料库中的文件总数

包含ti文件的数目

TF-IDF：

某一特定文件内的高词语频率，以及该词语在整个文件集合中的低文件频率，可以产生出高权重的TF-IDF。因此，TF-IDF倾向于过滤掉常见的词语，保留重要的词语。
TFIDF的主要思想是：如果某个词或短语在一篇文章中出现的频率TF高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。

package test.mr.tfidf;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class FirstJob {

    public static void main(String[] args) {
        Configuration conf = new Configuration();
        conf.set("mapreduce.app-submission.coress-paltform", "true");
        conf.set("mapreduce.framework.name", "local");
        try {
            FileSystem fs = FileSystem.get(conf);
            Job job = Job.getInstance(conf);
            job.setJarByClass(FirstJob.class);
            job.setJobName("weibo1");

            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
            job.setNumReduceTasks(4);
            job.setPartitionerClass(FirstPartition.class);
            job.setMapperClass(FirstMapper.class);
            job.setCombinerClass(FirstReduce.class);
            job.setReducerClass(FirstReduce.class);

            FileInputFormat.addInputPath(job, new Path("/root/tfidf/input/"));

            Path path = new Path("/root/tfidf/output/weibo1");
            if (fs.exists(path)) {
                fs.delete(path, true);
            }
            FileOutputFormat.setOutputPath(job, path);

            boolean f = job.waitForCompletion(true);
            if (f) {

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
package test.mr.tfidf;

import java.io.IOException;
import java.io.StringReader;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.wltea.analyzer.core.IKSegmenter;
import org.wltea.analyzer.core.Lexeme;

/**
 * 第一个MR，计算TF和计算N(微博总数)
 * 
 * @author root
 *
 */
public class FirstMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

    protected void map(LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {
        //3823890210294392    今天我约了豆浆，油条
        String[] v = value.toString().trim().split("\t");
        
        if (v.length >= 2) {
            
            String id = v[0].trim();
            String content = v[1].trim();

            StringReader sr = new StringReader(content);
            IKSegmenter ikSegmenter = new IKSegmenter(sr, true);
            Lexeme word = null;
            while ((word = ikSegmenter.next()) != null) {
                String w = word.getLexemeText();
                context.write(new Text(w + "_" + id), new IntWritable(1));
                //今天_3823890210294392    1
            }
            context.write(new Text("count"), new IntWritable(1));
            //count 1
            
        } else {
            System.out.println(value.toString() + "-------------");
        }
    }

}
package test.mr.tfidf;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;

/**
 * 第一个MR自定义分区
 * @author root
 *
 */
public class FirstPartition extends HashPartitioner<Text, IntWritable>{

    
    public int getPartition(Text key, IntWritable value, int reduceCount) {
        if(key.equals(new Text("count")))
            return 3;
        else
            return super.getPartition(key, value, reduceCount-1);
    }

}
package test.mr.tfidf;

import java.io.IOException;

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

/**
 * c1_001,2 c2_001,1 count,10000
 * 
 * @author root
 *
 */
public class FirstReduce extends Reducer<Text, IntWritable, Text, IntWritable> {

    protected void reduce(Text key, Iterable<IntWritable> iterable,
            Context context) throws IOException, InterruptedException {

        int sum = 0;
        for (IntWritable i : iterable) {
            sum = sum + i.get();
        }
        if (key.equals(new Text("count"))) {
            System.out.println(key.toString() + "___________" + sum);
        }
        context.write(key, new IntWritable(sum));
    }
}
package test.mr.tfidf;


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.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;


public class TwoJob {

    public static void main(String[] args) {
        Configuration conf =new Configuration();
        conf.set("mapreduce.app-submission.coress-paltform", "true");
        conf.set("mapreduce.framework.name", "local");
        
        
        try {
            Job job =Job.getInstance(conf);
            job.setJarByClass(TwoJob.class);
            job.setJobName("weibo2");
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
            job.setMapperClass(TwoMapper.class);
            job.setCombinerClass(TwoReduce.class);
            job.setReducerClass(TwoReduce.class);
            
            //mr运行时的输入数据从hdfs的哪个目录中获取
            FileInputFormat.addInputPath(job, new Path("/data/tfidf/output/weibo1"));
            FileOutputFormat.setOutputPath(job, new Path("/data/tfidf/output/weibo2"));
            
            boolean f= job.waitForCompletion(true);
            if(f){
                System.out.println("执行job成功");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
package test.mr.tfidf;
import java.io.IOException;

import org.apache.hadoop.io.IntWritable;
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;

//统计df：词在多少个微博中出现过。
public class TwoMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

    protected void map(LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {

        // 获取当前 mapper task的数据片段（split）
        FileSplit fs = (FileSplit) context.getInputSplit();
        
        if (!fs.getPath().getName().contains("part-r-00003")) {

            //豆浆_3823890201582094    3
            String[] v = value.toString().trim().split("\t");
            if (v.length >= 2) {
                String[] ss = v[0].split("_");
                if (ss.length >= 2) {
                    String w = ss[0];
                    context.write(new Text(w), new IntWritable(1));
                }
            } else {
                System.out.println(value.toString() + "-------------");
            }
        }
    }
}
package test.mr.tfidf;

import java.io.IOException;

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

public class TwoReduce extends Reducer<Text, IntWritable, Text, IntWritable> {

    protected void reduce(Text key, Iterable<IntWritable> arg1, Context context)
            throws IOException, InterruptedException {

        int sum = 0;
        for (IntWritable i : arg1) {
            sum = sum + i.get();
        }

        context.write(key, new IntWritable(sum));
    }

}
package test.mr.tfidf;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.TextInputFormat;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;


public class LastJob {

    public static void main(String[] args) {
        Configuration conf =new Configuration();
//        conf.set("mapred.jar", "C:\\Users\\root\\Desktop\\tfidf.jar");
        //conf.set("mapreduce.job.jar", "C:\\Users\\root\\Desktop\\tfidf.jar");
        
        conf.set("mapreduce.app-submission.cross-platform", "true");
        
        
        try {
            FileSystem fs =FileSystem.get(conf);
            Job job =Job.getInstance(conf);
            job.setJarByClass(LastJob.class);
            job.setJobName("weibo3");
            job.setJar("C:\\Users\\root\\Desktop\\tfidf.jar");
            
            //2.5
            //把微博总数加载到
            job.addCacheFile(new Path("/root/tfidf/output/weibo1/part-r-00003").toUri());
            //把df加载到
            job.addCacheFile(new Path("/root/tfidf/output/weibo2/part-r-00000").toUri());
            
            
            
            
            
            //设置map任务的输出key类型、value类型
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(Text.class);
            job.setMapperClass(LastMapper.class);
            job.setReducerClass(LastReduce.class);
            
            //mr运行时的输入数据从hdfs的哪个目录中获取
            FileInputFormat.addInputPath(job, new Path("/data/tfidf/output/weibo1"));
            Path outpath =new Path("/root/tfidf/output/weibo3");
            if(fs.exists(outpath)){
                fs.delete(outpath, true);
            }
            FileOutputFormat.setOutputPath(job,outpath );
            
            boolean f= job.waitForCompletion(true);
            if(f){
                System.out.println("执行job成功");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
package test.mr.tfidf;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.net.URI;
import java.text.NumberFormat;
import java.util.HashMap;
import java.util.Map;

import org.apache.hadoop.fs.Path;
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;

/**
 * 最后计算
 * 
 * @author root
 *
 */
public class LastMapper extends Mapper<LongWritable, Text, Text, Text> {
    // 存放微博总数
    public static Map<String, Integer> cmap = null;
    // 存放df
    public static Map<String, Integer> df = null;

    // 在map方法执行之前
    protected void setup(Context context) throws IOException,
            InterruptedException {
        System.out.println("******************");
        if (cmap == null || cmap.size() == 0 || df == null || df.size() == 0) {

            URI[] ss = context.getCacheFiles();
            if (ss != null) {
                for (int i = 0; i < ss.length; i++) {
                    URI uri = ss[i];
                    if (uri.getPath().endsWith("part-r-00003")) {// 微博总数
                        Path path = new Path(uri.getPath());
                        // FileSystem fs
                        // =FileSystem.get(context.getConfiguration());
                        // fs.open(path);
                        BufferedReader br = new BufferedReader(new FileReader(path.getName()));
                        String line = br.readLine();
                        if (line.startsWith("count")) {
                            String[] ls = line.split("\t");
                            cmap = new HashMap<String, Integer>();
                            cmap.put(ls[0], Integer.parseInt(ls[1].trim()));
                        }
                        br.close();
                    } else if (uri.getPath().endsWith("part-r-00000")) {// 词条的DF
                        df = new HashMap<String, Integer>();
                        Path path = new Path(uri.getPath());
                        BufferedReader br = new BufferedReader(new FileReader(path.getName()));
                        String line;
                        while ((line = br.readLine()) != null) {
                            String[] ls = line.split("\t");
                            df.put(ls[0], Integer.parseInt(ls[1].trim()));
                        }
                        br.close();
                    }
                }
            }
        }
    }

    protected void map(LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {
        FileSplit fs = (FileSplit) context.getInputSplit();
        // System.out.println("--------------------");
        
        
        if (!fs.getPath().getName().contains("part-r-00003")) {

            //豆浆_3823930429533207    2
            String[] v = value.toString().trim().split("\t");
            if (v.length >= 2) {
                int tf = Integer.parseInt(v[1].trim());// tf值
                String[] ss = v[0].split("_");
                if (ss.length >= 2) {
                    String w = ss[0];
                    String id = ss[1];

                    double s = tf * Math.log(cmap.get("count") / df.get(w));
                    NumberFormat nf = NumberFormat.getInstance();
                    nf.setMaximumFractionDigits(5);
                    context.write(new Text(id), new Text(w + ":" + nf.format(s)));
                }
            } else {
                System.out.println(value.toString() + "-------------");
            }
        }
    }
}
package test.mr.tfidf;

import java.io.IOException;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class LastReduce extends Reducer<Text, Text, Text, Text> {

    protected void reduce(Text key, Iterable<Text> iterable, Context context)
            throws IOException, InterruptedException {

        StringBuffer sb = new StringBuffer();

        for (Text i : iterable) {
            sb.append(i.toString() + "\t");
        }

        context.write(key, new Text(sb.toString()));
    }

}

 

转载于:https://www.cnblogs.com/cac2020/p/10312979.html

Hadoop MapReduce实现tfidf源码
05-18
用MapReduce实现TF-IDF，Hadoop版本是2.7.7，参考某教程亲自手写的，可以运行，有问题可以留言
【MapReduce】使用MapReduce实现TF-IDF算法
HR的博客
04-05 2164
使用MapReduce实现TF-IDF算法TF-IDF的介绍需求及实现步骤需求实现步骤代码实现设置IK分词及其扩展停止词字典自定义类接收MySQL里的数据第一个Mapper自定义分区第一个Reduce第二个Mapper自定义分组第二个Reduce自定义类接收存储到MySQL的数据第三个Mapper第三个ReduceDriver阶段结果 TF-IDF的介绍 TFIDF全程叫做term frequency–inverse document frequency，翻译过来可以叫做文本频率与逆文档频率指数, TF
MapReduce 应用：TF-IDF 分布式实现
weixin_30902675的博客
06-24 385
概述 本文要说的 TF-IDF 分布式实现，运用了很多之前 MapReduce 的核心知识点。算是 MapReduce 的一个小应用吧。 版权说明 著作权归作者所有。 商业转载请联系作者获得授权，非商业转载请注明出处。 本文作者：Q-WHai 发表日期： 2016年6月24日 本文链接：http://blog.csdn.net/lemon_tree1213...
hadoop基于MapReduce实现TFIDF算法完成热点词汇抓取
12-14 2151
hadoop基于MapReduce实现TFIDF算法完成热点词汇抓取首先了解TFIDF环境步骤开始 首先了解TFIDF TF-IDF的主要思想是，如果某个词或短语在一篇文章中出现的频率TF高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。TF词频(Term Frequency)指的是某一个给定的词语在该文件中出现的次数。IDF反文档频率(Inverse Docu...
【hadoop 03】mapreduce-TF-IDF案例
SWEENEY_HE的博客
12-02 408
一、TF-IDF介绍    TF-IDF全称为term frequency inverse document frequency 词频逆文本指数，是一种用于信息检索与数据挖掘的常用加权技术。 TF_IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降...
基于MapReduce的TF-IDF统计.zip
最新发布
03-13
标题中的“基于MapReduce的TF-IDF统计”指的是在大数据处理场景中，使用Hadoop的MapReduce框架来计算文本数据的TF-IDF值。TF-IDF（Term Frequency-Inverse Document Frequency）是一种常用的文本特征提取方法，它能...
hadoop2.5.2学习13-MR之新浪微博
03-19
本教程主要探讨的是在Hadoop 2.5.2版本中，如何利用MapReduce处理大规模数据，特别是针对新浪微博的数据进行TF-IDF算法的实现。TF-IDF（Term Frequency-Inverse Document Frequency）是一种用于信息检索和文本挖掘的...
MapReduce课程设计3-邮件自动分类1
08-03
【MapReduce课程设计3-邮件自动分类1】的目的是通过Hadoop的MapReduce编程实现邮件的自动分类，以此提升对MapReduce的理解和应用能力。在这个过程中，学生将学习到如何利用第三方库处理大数据任务，以及如何设计...
大数据Hadoop学习之——TF-IDF算法实现
xdkb159的博客
08-19 1642
一、算法说明 1、词频TF：是指给定词语在给定文件中出现的次数，一般会做归一化，即除以文件的总词数（注意是分词数，不是字数）。 TF=词在文章出现次数 / 文章的总词数 2、逆向文件频率IDF：普遍重要性度量，由文件总数除以包含该词的文件的数目，再对商取对数。 IDF=log(文件总数 / 包含目标词的文件个...
基于MapReduce实现的TFIDF计算
07-10
基于MR实现的TFIDF相似度的计算过程，可以深刻理解mapreducer的过程同时了解TFIDF计算过程
【Hadoop】MapReduce案例——TFIDF案例
啥也不会~
04-25 1674
MapReduce案例——TFIDF案例
大数据学习之路（十一）——MapReduce实战(TF-IDF)
recover517的博客
07-03 2996
本次项目必须在完全部分下执行，单机或者伪分布应该都执行不了，会提示找不到文件。 项目介绍：TF-IDF TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。TF-IDF加权的各种形式常被搜索引擎应用，作为文件与用户查询之间相关程度的度量或评...
运用mapreduce计算tf-idf
成就源于知识，知识在于积累。
03-19 3116
运用mapreduce计算文档中每个单词的tfidf值
《Hadoop与大数据挖掘》一2.6　TF-IDF算法原理及Hadoop MapReduce实现
weixin_34279061的博客
06-26 169
本节书摘来华章计算机《Hadoop与大数据挖掘》一书中的第2章 ，第2.6节，张良均　樊　哲　位文超　刘名军 许国杰　周　龙　焦正升　著 更多章节内容可以访问云栖社区“华章计算机”公众号查看。 2.6　TF-IDF算法原理及Hadoop MapReduce实现 2.6.1　TF-IDF算法原理原理：在一份给定的文件里，词频（Term Frequency，...
MapReduce中练习使用API编程：词频统计（TF-IDF）
wyqwilliam的博客
09-24 1019
TFIDF算法Hadoop实现
06-12 2255
利用HADOOP实现TFIDF算法
运用hadoop计算TF-IDF
jackydai987的专栏
04-05 9629
这几天一直在忙着找暑假实习，实在没精力来写新的文章。刚好这几天放假，我把前几天做了的另一个例子拿出来跟大家分享一下。这个例子是使用hadoop来实现TF-IDF。TF-IDF（term frequency–inverse document frequency）是一种用于资讯检索与资讯探勘的常用加权技术。具体的信息就麻烦大家自己百度一下了。因为要实现的细节比较多，所以我直接将代码放上来。大家可以参看代码里面的注释，我写的比较详细。我采用了两个MapReduce任务顺序执行来实现TF-IDF功能。public
初学Hadoop之计算TF-IDF值
weixin_30706507的博客
05-09 157
1.词频 TF(term frequency)词频，就是该分词在该文档中出现的频率，算法是：（该分词在该文档出现的次数）/(该文档分词的总数)，这个值越大表示这个词越重要，即权重就越大。 例如：一篇文档分词后，总共有500个分词，而分词”Hello”出现的次数是20次，则TF值是： tf =20/500=0.04 　　考虑到文章有长短之分，为了便于不同文章的比较，进行"词频...
使用MapReduce实现TF-IDF算法详细步骤
"案例TF-IDF.pdf是一个关于使用MapReduce实现TF-IDF算法的教程，作者提供了源码供参考。TF-IDF是一种在信息检索和文本挖掘中常用的权重计算方法，用于评估一个词在文档中的重要性。这个案例分为三次MapReduce作业来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值