【Hadoop】MapReduce案例——TFIDF案例

已于 2022-05-05 10:03:03 修改
阅读量1.5k 收藏 4
点赞数 1
文章标签： 大数据
于 2022-04-25 22:04:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cz_19970522/article/details/124415511
版权

文章目录

一、前期准备

可参考 “词频统计” 案例中的前期准备阶段

二、数据准备

采用微博爬取数据weibo.txt

三、TF计算

1.TfJob.class

package com.hdtrain.tfidf;

import com.google.inject.internal.cglib.core.$AbstractClassGenerator;
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.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class TfJob {
    public static void main(String[] args) {
        Configuration configuration = new Configuration(true);
        configuration.set("mapreduce.framework.name", "local");

        try {
            FileSystem fs = FileSystem.get(configuration);
            Job job = Job.getInstance(configuration);
            job.setJarByClass(TfJob.class);
            job.setJobName("TF");

            job.setOutputKeyClass(TfBean.class);
            job.setOutputValueClass(IntWritable.class);
            job.setNumReduceTasks(3);
            job.setPartitionerClass(TfPartition.class);
            job.setMapperClass(TfMapper.class);
            job.setReducerClass(TfReducer.class);

            FileInputFormat.addInputPath(job, new Path("/data/weibo/"));

            Path path = new Path("/results/weibo/weibo-tf/");
            if (fs.exists(path)){
                fs.delete(path, true);
            }
            FileOutputFormat.setOutputPath(job, path);

            job.waitForCompletion(true);
        } catch (IOException | InterruptedException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

2.TfMapper.class

package com.hdtrain.tfidf;

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;

import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;

public class TfMapper extends Mapper<LongWritable, Text, TfBean, IntWritable> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] v = value.toString().trim().split("\t");
        if (v.length>=2){
            // 开始拆分数据
            String id = v[0].trim();
            String content = v[1].trim();
            //定义一个List存放分词器获取的值
            List<String> words = new ArrayList<>();
            //开始分词
            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 TfBean(id, w), new IntWritable(1));
            }
            context.write(new TfBean("count", ""), new IntWritable(1));
        }

    }
}

3.TfReducer.class

package com.hdtrain.tfidf;

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

import javax.swing.*;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class TfReducer extends Reducer<TfBean, IntWritable, Text, DoubleWritable> {
    @Override
    protected void reduce(TfBean key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int sum = 0; // 一篇微博中总共出现了多少个单词
        //统计一篇微博中每个词出现的次数
        Map<TfBean, Integer> map = new HashMap<>();
        for (IntWritable i:values){
            sum = sum + i.get();
            //判断是否存在，如果存在就累加，不存在就初始化为1
            TfBean tfBean = new TfBean(key.getId(), key.getWord());
            if (map.containsKey(tfBean)){
                map.put(tfBean, map.get(tfBean) + 1);
            } else {
                map.put(tfBean, 1);
            }
        }
        //开始迭代写数据
        if (key.getId().equals("count")){
            context.write(new Text("count"), new DoubleWritable(sum));
        } else {
            for (Map.Entry<TfBean, Integer> entry: map.entrySet()){
                context.write(new Text(entry.getKey().getWord() + "_" + entry.getKey().getId()), new DoubleWritable(entry.getValue() * 1.0 / sum));
            }
        }
    }
}

4.TfBean.class

package com.hdtrain.tfidf;

import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

public class TfBean implements WritableComparable<TfBean> {
    private String id;
    private String word;

    public void setId(String id) {
        this.id = id;
    }

    public void setWord(String word) {
        this.word = word;
    }

    public String getId() {
        return id;
    }

    public String getWord() {
        return word;
    }

    public TfBean() {
    }

    public TfBean(String id, String word) {
        super();
        this.id = id;
        this.word = word;
    }

    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeUTF(id);
        dataOutput.writeUTF(word);
    }

    @Override
    public void readFields(DataInput dataInput) throws IOException {
        this.id = dataInput.readUTF();
        this.word = dataInput.readUTF();
    }

    @Override
    public int compareTo(TfBean o) {
        int results = this.id.compareTo(o.getId());
        return results;
    }

    @Override
    public int hashCode() {
        return super.hashCode();
    }
}

5.TfPartition.class

package com.hdtrain.tfidf;

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


public class TfPartition extends HashPartitioner<TfBean, IntWritable> {
    @Override
    public int getPartition(TfBean key, IntWritable value, int numReduceTasks) {
        if (key.getId().equals("count")){
            return numReduceTasks - 1;  // id为count的由标号为2的主机处理
        } else {
            return Math.abs(key.getId().hashCode()) % (numReduceTasks -1); // 其余由标号为0、1的主机处理
        }
    }
}

6.计算结果
在这里插入图片描述
在这里插入图片描述

四、IDF计算

1.IdfJob.class

package com.hdtrain.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;

import java.io.IOException;

public class IdfJob {
    public static void main(String[] args) {
        Configuration configuration = new Configuration(true);
        configuration.set("mapreduce.framework.name", "local");

        try {
            FileSystem fs = FileSystem.get(configuration);
            Job job = Job.getInstance(configuration);
            job.setJarByClass(IdfJob.class);
            job.setJobName("IDF");

            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
            job.setMapperClass(IdfMapper.class);
            job.setCombinerClass(IdfReducer.class);
            job.setReducerClass(IdfReducer.class);

            FileInputFormat.addInputPath(job, new Path("/results/weibo/weibo-tf"));
            Path path = new Path("/results/weibo/weibo-idf");
            if (fs.exists(path)){
                fs.delete(path, true);
            }
            FileOutputFormat.setOutputPath(job, path);
            job.waitForCompletion(true);
        } catch (IOException | InterruptedException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

2.IdfMapper.class

package com.hdtrain.tfidf;

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;

import java.io.IOException;

public class IdfMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        // 获取当前mapper task的数据片段（split）
        FileSplit fs = (FileSplit) context.getInputSplit();
        //只计算除了002以外的切片
        if (!fs.getPath().getName().contains("part-r-00002")){
            String[] v = value.toString().trim().split("\t");
            if (v.length >= 2){
                String[] ss = v[0].split("_");
                if (ss.length >= 2){
                    String word = ss[0];
                    context.write(new Text(word), new IntWritable(1));
                }
            }
        }
    }
}

3.IdfReducer.class

package com.hdtrain.tfidf;

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

import java.io.IOException;

public class IdfReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int sum = 0;
        for (IntWritable i: values){
            sum = sum + i.get();
        }

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

4.计算结果
在这里插入图片描述

五、TFIDF计算

1.TfidfJob.class

package com.hdtrain.tfidf;

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

import java.io.IOException;

public class TfidfJob {
    public static void main(String[] args) {
        Configuration configuration = new Configuration(true);
        configuration.set("mapreduce.framework.name", "local");

        try {
            Job job = Job.getInstance(configuration);
            job.setJarByClass(TfidfJob.class);
            job.setJobName("TFIDF");
            //加载微博总数到缓存文件
            job.addCacheFile(new Path("/results/weibo/weibo-tf/part-r-00002").toUri());
            //加载每个词在文章中的出现次数
            job.addCacheFile(new Path("/results/weibo/weibo-idf/part-r-00000").toUri());

            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(Text.class);
            job.setMapperClass(TfidfMapper.class);
            job.setReducerClass(TfidfReducer.class);

            FileInputFormat.addInputPath(job, new Path("/results/weibo/weibo-tf"));
            Path path = new Path("/results/weibo/weibo-tfidf");
            FileSystem fs = FileSystem.get(configuration);
            if (fs.exists(path)){
                fs.delete(path, true);
            }
            FileOutputFormat.setOutputPath(job, path);
            job.waitForCompletion(true);
        } catch (IOException | InterruptedException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

2.TfidfMapper.class

package com.hdtrain.tfidf;

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.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;

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

public class TfidfMapper extends Mapper<LongWritable, Text, Text, Text> {
    //存放微博总数
    public static Double weibo_count;
    //存放出现某个词语的微博数
    public static Map<String, Integer> wordInText = null;

    protected void setup(Context context) throws IOException {
        URI[] cacheFile = context.getCacheFiles();
        if (cacheFile != null){
            for (int i=0;i < cacheFile.length;i++){
                //获取缓存文件名称
                URI uri = cacheFile[i];
                //微博总数
                if (uri.getPath().endsWith("part-r-00002")){
                    //定义文件路径
                    Path path = new Path(uri.getPath());
                    //获取字符流
                    BufferedReader br = new BufferedReader(new FileReader(path.getName()));
                    //读取一行
                    String line = br.readLine();
                    if (line.startsWith("count")){
                        String[] ls = line.split("\t");
                        weibo_count = Double.parseDouble(ls[1].trim());
                    }
                    br.close();
                } else if (uri.getPath().endsWith("part-r-00000")){ //词条的tf
                    wordInText = 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");
                        wordInText.put(ls[0], Integer.parseInt(ls[1].trim()));
                    }
                    br.close();
                }
            }
        }
    }

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        // 获取当前mapper task的数据片段（split）
        FileSplit fs = (FileSplit) context.getInputSplit();
        //只计算除了002以外的切片
        if (!fs.getPath().getName().contains("part-r-00002")){
            String[] v = value.toString().trim().split("\t");
            if (v.length >= 2){
                double tf = Double.parseDouble(v[1].trim());
                String[] ss = v[0].split("_");
                if (ss.length >= 2){
                    String w= ss[0];
                    String id= ss[1];
                    //计算tfidf
                    double tfidf = tf * Math.log(weibo_count / wordInText.get(w));
                    NumberFormat nf = NumberFormat.getInstance();
                    nf.setMaximumFractionDigits(5);
                    context.write(new Text(id), new Text(w+":"+nf.format(tfidf)));
                }
            } else {
                System.out.println(value.toString() + "---------------------");
            }
        }
    }
}

3.TfidfReducer.class

package com.hdtrain.tfidf;

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

import java.io.IOException;

public class TfidfReducer extends Reducer<Text, Text, Text, Text> {
    @Override
    protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
        StringBuffer sb = new StringBuffer();
        for (Text i: values){
            sb.append(i.toString() + "\t");
        }
        context.write(key, new Text(sb.toString()));
    }
}

4.计算结果
在这里插入图片描述

嗯，哦，呵呵。
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hadoop MapReduce实现tfidf源码
05-18
用MapReduce实现TF-IDF，Hadoop版本是2.7.7，参考某教程亲自手写的，可以运行，有问题可以留言
运用mapreduce计算tf-idf
weixin_33725126的博客
01-13 142
问题描写叙述：给定一个大文件，文件里的内容每一行为：文档名，文档内容。 input 文档名1，word1 Word2 ....... 文档名2，word1 Word2 ....... output word  文档名  tfidf值 package com.elex.mapreduce; import java.io.IOException; import java.ne...
《Hadoop与大数据挖掘》——2.6　TF-IDF算法原理及Hadoop MapReduce实现
weixin_34204057的博客
07-03 335
本节书摘来自华章计算机《Hadoop与大数据挖掘》一书中的第2章，第2.6节，作者 张良均 樊哲 位文超 刘名军 许国杰 周龙 焦正升，更多章节内容可以访问云栖社区“华章计算机”公众号查看。 2.6　TF-IDF算法原理及Hadoop MapReduce实现 2.6.1　TF-IDF算法原理 原理：在一份给定的文件里，词频（Term Frequency，...
Python文本数据分析：新闻分类任务（贝叶斯，TF-IDF词向量）
王大阳的博客
06-18 9341
基本思路 1.文本分析 2.关键词提取 3.新闻数据与任务简介 4.TF-IDF关键词提取 5.LDA建模 6.基于贝叶斯算法进行新闻分类 1.文本分析 11.查看数据 import pandas as pd import jieba df_news = pd.read_table('./data/val.txt',names=['category','theme','URL','content'...
【MapReduce】TF-IDF
懂得一千零一种,赋予你失败的方法！
04-07 551
文章目录TF-IDF一、概述二、案例_统计猫眼电影数据中的TF-IDF1.整体思路2.代码实现Step 1 — 计算 TFpart 1：自定义SQLBean获取需要数据part 2：编写Mapper1类part 3：编写Reducer1类part 4：编写Partition分区类Step 2 — 计算 IDFpart 1：编写Mapper2类part 2：编写Reducer2类Step 3 — 计算 TF-IDFpart 1：自定义BeanSQL收集结果数据集part 2：编写Mapper3类part ..
朴素贝叶斯的应用_TF-IDF实例
weixin_41479678的博客
05-26 1887
sklearn 的全称叫 Scikit-learn，它给我们提供了 3 个朴素贝叶斯分类算法，分别是高斯朴素贝叶斯（GaussianNB）、多项式朴素贝叶斯（MultinomialNB）和伯努利朴素贝叶斯（BernoulliNB）。 这三种算法适合应用在不同的场景下，我们应该根据特征变量的不同选择不同的算法： 高斯朴素贝叶斯 ：特征变量是连续变量，符合高斯分布，比如说人的身高，物体的长度。 多项式朴素贝叶斯 ：特征变量是离散变量，符合多项分布，在文档分类中特征变量体现在一个单词出现的次数，或者是单词的 TF
基于MapReduce实现的TFIDF计算
07-10
在实际项目中，可能会使用Hadoop或者其他支持MapReduce的框架来实现这个过程。 总结来说，基于MapReduce的TF-IDF计算是一个将分布式计算与文本分析相结合的过程，它能够高效地处理大量文档并计算出词的重要程度。...
基于MapReduce编程模型的TFIDF算法研究
10-17
现有的文本分类算法在时间复杂性和空间复杂性上遇到瓶颈，不能满足人们的需求，为此提出了基于Hadoop分布式平台的TFIDF算法，给出了算法实现的具体流程，通过MapReduce编程实现了该算法，并在单机和集群模式下进行了...
基于Hadoop+TFIDF+VSM+Kmeans的文本聚类程序.zip
最新发布
03-13
Hadoop的核心组件包括HDFS（Hadoop Distributed File System）和MapReduce，前者提供了高容错性的分布式存储，后者则为分布式计算提供了编程模型。 【TF-IDF】是一种在信息检索和文本挖掘中广泛使用的统计方法，...
用MapReduce开发的一个TFIDF 计算关键字权重
12-05
在Hadoop集群中，用MapReduce分布式计算TFIDF
TFIDF案例
zoe_ranxiaosu的博客
03-06 1860
TF-IDF（term frequency-inverse document frequency）是一种用于咨询检索与咨询探勘的常用加权技术。 --TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。 字词的重要性随着它在文件中出现的次数成正比增加 但同时会随着它在语料库中出现的频率成反比下降 --TF-IDF加权的各...
Hadoop计算文档的中每个词的TFIDF值
linglingbaby的专栏
07-27 1180
做数据挖掘的最常见的就是要对文档向量化，而向量化表示中最常见的就是TFIDF了。那么对于海量数据我们该如何计算呢？本文讲解一下使用Hadoop计算TFIDF值的步骤，在其它地方也有不少这方面的介绍，本文仅供参考。 在本地进行TFIDF计算需要三步：1.       统计数据集中独
文本向量表示及TFIDF词汇权值
weixin_30682415的博客
05-14 556
文本相似计算是进行文本聚类的基础，和传统结构化数值数据的聚类方法类似，文本聚类是通过计算文本之间"距离"来表示文本之间的相似度并产生聚类。文本相似度的常用计算方法有余弦定理和Jaccard系数。但是文本数据与普通的数值数据或类属数据不同，文本数据是一种半结构化数据，在进行文本挖掘之前必须要对文本数据源进行处理，如分词、向量化表示等，其目的就是使用量化的数值来表达这些半结构化的文本数据。使其...
MapReduce实现分词和倒排索引(算法TF-IDF)
尹忠政的博客
06-02 1088
MapReduce实现分词和倒排索引(算法TF-IDF) 介绍IFDF IF：词频（单词在文档中出现的次数/文档中的总词数） DF：逆向文件频率（log(文档总数/出现该单词的文件数量)），log归一化，避免了一些常用词如 的,了等词的评分 IF/DF能表明单词在索引(文档库)的重要程度 输入文件 id \t 文本内容 3823891101582094 我爱中国 3823891201582...
Mapreduce 部分：案例分析（TF-IDF（term frequency–inverse document frequency））
wyqwilliam的博客
07-08 1594
Mapreduce 案例分析（TF-IDF（term frequency–inverse document frequency）） 一．需求介绍 二．思路分析 概念 TF-IDF（term frequency–inverse document frequency）是一种用于资讯检索与资讯探勘的常用加权技术。 TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份...
推荐算法之CB，CF的实现
Jameslvt的博客
07-30 4528
上篇我们分析了CB，CF算法的原理，这里我们补充一下推荐系统的推荐场景的流程图： 从推荐场景的流程图中，我们可以看到，最重要的部分就是这个索引库怎么计算得到，当然，不同的算法之间的实现方式不一样，首先我们来说一下CB算法，CB算法的实现主要是基于用户的历史行为（引入用户属性 CB）和用户当下购买的物品（引入item属性）进行推荐，主要的实现方法是正排—》倒排索引式的实现方法，那么接下来我们来...
《Hadoop与大数据挖掘》一2.6.3　Hadoop TF-IDF编程实现
weixin_33739646的博客
06-26 120
本节书摘来华章计算机《Hadoop与大数据挖掘》一书中的第2章 ，第2.6.3节，张良均　樊　哲　位文超　刘名军 许国杰　周　龙　焦正升　著 更多章节内容可以访问云栖社区“华章计算机”公众号查看。 2.6.3　Hadoop TF-IDF编程实现 这里给出的TF-IDF算法的测试数据使用的是Avro格式的。这里只对Avro进行简单介绍，如读者需要深入了解，...
python文本挖掘（二）——实例1（TF-IDF算法）
Seal_Wings的博客
10-30 6005
分析小说《玩偶之家》 参考链接： 文本可视化[一]——《今生今世》词云生成与小说分析
TF-IDF mapreduce实现
qq_43637099的博客
05-04 226
文章目录TFsetup（）函数map()函数combinereducer一些遇到的问题 TF setup（）函数 获取每个文件所属的作品名 map()函数 输出 key: word:workname val: 1 hadoop的context.write，必须保证有值写入，不能是null，如果是null会让map输出和reduce的输入不匹配而造成程序运行错误。 public static class TFMapper extends Mapper<Object, Text, Text, Te
hadoop mapreduce案例
03-16
Hadoop MapReduce 是一种分布式数据处理框架，用于大数据处理。一个常见的案例是统计网络日志中每个 IP 地址的访问次数。MapReduce 程序通过读取日志文件，将其转换为键值对形式，然后对键进行分组和排序，最终得出...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值