精华内容
下载资源
问答
  • java 实现 计算tfidf 使用ik分词

    java 实现 计算tfidf 使用ik分词 


    Doc类,即文档

    package pojo;
    
    import java.io.IOException;
    import java.io.Reader;
    import java.io.StringReader;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import org.wltea.analyzer.core.IKSegmenter;
    import org.wltea.analyzer.core.Lexeme;
    
    /**
     * Class description
     *
     *
     * @version        Enter version here..., 17/09/04
     * @author         Enter your name here...
     */
    public class Doc {
    
        /** 是否已分词标记 */
        private boolean isSeg = false;
    
        /** 标题 */
        private String title;
    
        /** url */
        private String url;
    
        /** 文档内容 */
        private String content;
    
        /** 文档编号 */
        private String docno;
    
        /** 分词后词项列表 */
        private List<String> segs;
    
        /** 词项计数Map */
        private Map<String, Integer> segMap;
    
        /**
         * Constructs ...
         *
         */
        public Doc() {}
    
        /**
         * Constructs ...
         *
         *
         * @param title
         * @param url
         * @param content 文档内容
         * @param docno 文档编号
         */
        public Doc(String url, String docno, String title,  String content) {
            this.title   = title;
            this.url     = url;
            this.content = content;
            this.docno   = docno;
        }
    
        /**
         * 分词
         * 对文档内容进行分词,使用ik分词器
         *
         */
        public void seg() {
            if (isSeg()){//判断是否已分词
                System.out.println("已分词");
                return;
            }
    
            Reader      reader      = new StringReader(content);
            IKSegmenter ikSegmenter = new IKSegmenter(reader, true);
            Lexeme      lexeme      = null;
            segs = new ArrayList<String>();
            segMap = new HashMap<String, Integer>();
            try {
                while ((lexeme = ikSegmenter.next()) != null) {
                    System.out.println(lexeme.getLexemeText());
                    segs.add(lexeme.getLexemeText());
                    if (segMap.containsKey(lexeme.getLexemeText())) {
                        segMap.put(lexeme.getLexemeText(), segMap.get(lexeme.getLexemeText()) + 1);
                    } else {
                        segMap.put(lexeme.getLexemeText(), 1);
                    }
                }
    
                isSeg = true;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        @Override
        public String toString() {
            return "Doc{" +
                    "isSeg=" + isSeg +
                    ", title='" + title + '\'' +
                    ", url='" + url + '\'' +
                    ", content='" + content + '\'' +
                    ", docno='" + docno + '\'' +
                    ", segs=" + segs +
                    ", segMap=" + segMap +
                    '}';
        }
    
        /**
         * Method description
         *
         *
         * @return
         */
        public String getContent() {
            return content;
        }
    
        /**
         * Method description
         *
         *
         * @return
         */
        public String getDocno() {
            return docno;
        }
    
        /**
         * 判断是否已分词
         *
         * @return
         */
        public boolean isSeg() {
            return isSeg;
        }
    
        /**
         * Method description
         *
         *
         * @return
         */
        public Map<String, Integer> getSegMap() {
            return segMap;
        }
    
        /**
         * Method description
         *
         *
         * @return
         */
        public List<String> getSegs() {
            return segs;
        }
    
        /**
         * Method description
         *
         *
         * @return
         */
        public String getTitle() {
            return title;
        }
    
    
        /**
         * Method description
         *
         *
         * @return
         */
        public String getUrl() {
            return url;
        }
    }
    
    
    //~ Formatted by Jindent --- http://www.jindent.com
    

    TfIdfUtil类,即计算tfidf工具类

    package util;
    
    import java.io.*;
    
    import java.util.*;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    import pojo.Doc;
    
    /**
     * 计算TfIdf
     * 根据给定语料库(这里采用搜狗中文新闻开放预料库)
     * 对文档集中各文档进行内容提取、分词
     * 分别计算tf idf tfidf
     * 并同时输出结果至控制台和目标文件
     *
     * @version        v0.1, 17/09/04
     * @author         Kiwi Liu
     */
    public class TfIdfUtil {
    
        /** 文档集 */
        private static List<Doc> docList = new ArrayList<Doc>();
    
        /** 文档集中各文档的词项频率 */
        private static Map<String, Map<String, Double>> docSetTfMap = new HashMap<String, Map<String, Double>>();
    
        /** 文档集中各词项的文档频数 */
        private static Map<String, Integer> docSetDcMap = new HashMap<String, Integer>();
    
        /** 文档集中各词项的逆向文档频率 */
        private static Map<String, Double> docSetIdfMap = new HashMap<String, Double>();
    
        /**
         * 根据语料库文件创建文档集并对每个文档进行分词和词项计数
         * 这里利用正则表达式进行标题、url、标号、内容的抽取和去除标签
         *
         * @param corpusPath
         */
        private static void createDocSet(String corpusPath) {
            StringBuffer corpusBuffer = new StringBuffer();//语料库缓冲器
            String       line         = null;
    
            try {//读取语料库
                BufferedReader bufferedReader = new BufferedReader(new FileReader(new File(corpusPath)));
    
                while ((line = bufferedReader.readLine()) != null) {
                    corpusBuffer.append(line);
                }    //while
    
                //预处理部分
                //提取各个文档
                Pattern patternDoc = Pattern.compile("<doc>.*?</doc>");
                Matcher matcherDoc = patternDoc.matcher(corpusBuffer.toString());
    
                while (matcherDoc.find()) {
                    String title   = null;
                    String url     = null;
                    String docno   = null;
                    String content = null;
    
                    String  doc          = matcherDoc.group();
                    //提取标题
                    Pattern patternTitle = Pattern.compile("<contenttitle>.*</contenttitle>");
                    Matcher matcherTitle = patternTitle.matcher(doc);
    
                    if (matcherTitle.find()) {
                        title = matcherTitle.group();
                        //去除标签
                        Pattern patternTag = Pattern.compile("<.*?>");
                        Matcher matcherTag = patternTag.matcher(title);
    
                        title = matcherTag.replaceAll(" ");
                        System.out.println("title: " + title);
                    }
                    //提取url
                    Pattern patternUrl = Pattern.compile("<url>.*?</url>");
                    Matcher matcherUrl = patternUrl.matcher(doc);
    
                    if (matcherUrl.find()) {
                        url = matcherUrl.group();
    
                        Pattern patternTag = Pattern.compile("<.*?>");
                        Matcher matcherTag = patternTag.matcher(url);
    
                        url = matcherTag.replaceAll("");
                        System.out.println("url: " + url);
                    }
                    //提取文档标号
                    Pattern patternDocno = Pattern.compile("<docno>.*?</docno>");
                    Matcher matcherDocno = patternDocno.matcher(doc);
    
                    if (matcherDocno.find()) {
                        docno = matcherDocno.group();
    
                        Pattern patternTag = Pattern.compile("<.*?>");
                        Matcher matcherTag = patternTag.matcher(docno);
    
                        docno = matcherTag.replaceAll("");
                        System.out.println("docno: " + docno);
                    }
                    //提取内容
                    Pattern patternContent = Pattern.compile("<content>.*?</content>");
                    Matcher matcherContent = patternContent.matcher(doc);
    
                    if (matcherContent.find()) {
                        content = matcherContent.group();
    
                        Pattern patternTag = Pattern.compile("<.*?>");
                        Matcher matcherTag = patternTag.matcher(content);
    
                        content = matcherTag.replaceAll("");
                        System.out.println("content: " + content);
                    }
                    //创建文档
                    Doc d = new Doc(url, docno, title, content);
                    //分词
                    d.seg();
                    docList.add(d);
                }    // while
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    
        /**
         * 计算文档集的逆向文档频率
         *
         */
        private static void idf() {
            for (Doc doc : docList) {//统计各个词项的文档频数
                for (String seg : doc.getSegMap().keySet()) {
                    if (docSetDcMap.containsKey(seg)) {
                        docSetDcMap.put(seg, docSetDcMap.get(seg) + 1);
                    } else {
                        docSetDcMap.put(seg, 1);
                    }
                }
            }
    
            Set<String> segSet = docSetDcMap.keySet();
            //计算idf=log(size(doc set)/docs(d,w))
            for (String seg : segSet) {
                docSetIdfMap.put(seg, Math.log((double) docList.size() / (double) docSetDcMap.get(seg)));
            }
        }
    
        /**
         * 输出结果信息到控制台和目标文件
         *
         * @param dstPath 目标文件路径
         */
        private static void print(String dstPath) {
            try {
                BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(new File(dstPath)));
    
                for (Doc doc : docList) {
                    System.out.println(doc);
                    bufferedWriter.write(doc.toString());
                    bufferedWriter.newLine();
    
                    for (String seg : doc.getSegMap().keySet()) {
                        double tf      = docSetTfMap.get(doc.getDocno()).get(seg);
                        double idf     = docSetIdfMap.get(seg);
                        String segInfo = seg + " tf: " + tf + " idf: " + idf + " tfidf: " + tf * idf;
    
                        System.out.println(segInfo);
                        bufferedWriter.write(segInfo);
                        bufferedWriter.newLine();
                    }
                }
    
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 计算文档集各文档中的词项频率
         * tf=count(w,d)/size(d)
         */
        private static void tf() {
            for (Doc doc : docList) {//各文档
                Map<String, Double> docTf = new HashMap<String, Double>();//单篇文档的词项频率
    
                for (String seg : doc.getSegMap().keySet()) {//文档中各词项
                    docTf.put(seg, Double.valueOf((double) doc.getSegMap().get(seg) / (double) doc.getSegs().size()));
                    //tf=count(w,d)/size(d)
                }
    
                docSetTfMap.put(doc.getDocno(), docTf);
            }
        }
    
        /**
         * 计算tfidf
         *
         * @param corpusPath 语料库文件路径
         * @param dstPath  目标文件路径
         */
        public static void tfidf(String corpusPath, String dstPath) {
            createDocSet(corpusPath);
            tf();
            idf();
            print(dstPath);
        }
    }
    
    
    //~ Formatted by Jindent --- http://www.jindent.com
    


    展开全文
  • 利用python 计算文档的tfidf,步骤大概如下: 读入文档,对文档进行分词,每一段为一个字符串,分词用空格隔开,读入文档是一个长度为该文档段数的列表。 利用vectorizer生成词频矩阵X , 再利用tfidftransformer ...

    利用python 计算文档的tfidf,步骤大概如下:

    读入文档,对文档进行分词,每一段为一个字符串,分词用空格隔开,读入文档是一个长度为该文档段数的列表。

    利用vectorizer生成词频矩阵X , 再利用tfidftransformer 生成tfidf矩阵。

    代码如下:

    import jieba
    import numpy as np
    from sklearn import feature_extraction
    from sklearn.feature_extraction.text import TfidfTransformer
    from sklearn.feature_extraction.text import CountVectorizer
    
    
    text = """
    由张一山与唐艺昕主演的新版《鹿鼎记》备受争议,魔改的剧情和夸张的演技让人无法直视。作为主演的张一山承受了大部分观众的炮火,受尽无数吐槽。而在剧中扮演韦小宝老婆之一苏荃的朱珠却在采访中直面差评、硬刚网友,为张一山洗白。
    
    
    尽管大家已经做好了翻拍不如原版的准备,然而还是没有想到这一版本《鹿鼎记》会如此不尽人意,开播前有多受网友期待,开播后就让人感到有多失望。
    
    
    
    张一山版《鹿鼎记》在经历了剧情魔改、演员演技浮夸这一系列重创后,最终评分惨不忍睹。
    
    
    
    
    原以为有“戏骨”张一山坐镇扛剧,这部剧再差也不会差到哪里去,谁曾想整部剧最大的槽点就是张一山本人。
    
    
    过于浮夸的演技,油腻做作的肢体语言,被网友称为“猴式演技”,还有网友无情吐槽张一山“像被鞭子抽了三年的心酸小瘦猴在努力假装快乐活泼”。
    
    
    
    而朱珠在剧中扮演的则是韦小宝的御姐老婆苏荃,性格大气沉稳、临危不惧。朱珠所饰演的苏荃其实也并没有让人眼前一亮,演技总体来说还是有些流于表面,没有让整部剧口碑力挽狂澜。
    
    
    或许是戏份不多的原因,朱珠在这部戏中并没有被过多讨论,网友的炮火主要还是集中在主演张一山身上。不过朱珠参演的另外一部剧《大秦赋》也同样备受争议,并且戏份过多的朱珠还受到不少吐槽。
    
    
    《大秦赋》这部剧算是高开低走的典型,集结了张鲁一、段奕宏、邬君梅等演技派的历史大剧,是网友们相当期待的一部剧,朱珠在剧中扮演的是一代美人赵姬。
    
    
    作为秦始皇嬴政的生母,赵姬戏份过于拖沓,与嫪毐的情爱纠葛缠绵不断,被网友吐槽将《大秦赋》演成了《大情妇》或者是《嫪毐传》。
    
    
    赵姬这个角色若是演好了定能圈大波粉丝,不过朱珠却将其演绎成了只会傻笑的“傻白甜”,美则美矣,然而没有了灵魂。
    
    这边朱珠自己已经受到吐槽不断,受访时还是为旧搭档张一山发声,与给出差评的观众正面刚。
    
    朱珠表示张一山虽然看起来古灵精怪,其实是非常成熟并且大男人的一个人,心里也是非常有数。
    """
    
    word_list = text.split("\n")
    word_list
    new_word_list = [i for i in word_list if i != ""]
    new_word_list
    
    corpus = [" ".join(jieba.cut(w)) for w in new_word_list]
    corpus
    
    vectorizer = CountVectorizer()
    X = vectorizer.fit_transform(corpus)
    word = vectorizer.get_feature_names()
    word
    freq = X.toarray()
    freq
    
    transformer = TfidfTransformer()
    tfidf = transformer.fit_transform(X)
    
    tfidf.toarray()

     

    展开全文
  • 【甘道夫】基于sklearn计算tfidf时支持char + word模式

    千次阅读 多人点赞 2018-03-28 15:28:55
    欢迎转载,请注明原文链接:https://blog.csdn.net/u010967382/article/details/79728404本文不介绍sklearn计算tfidf的过程,网上文章很多,只指出一个坑及其解决方案。做tfidf计算有几行核心代码: vectorizer = ...

    欢迎转载,请注明原文链接:https://blog.csdn.net/u010967382/article/details/79728404

    本文不介绍sklearn计算tfidf的过程,网上文章很多,只指出一个坑及其解决方案。

    做tfidf计算有几行核心代码:
        vectorizer = CountVectorizer()    
        transformer = TfidfTransformer()
        tfidf = transformer.fit_transform(vectorizer.fit_transform(corpus))

    如果corpus中包含这样的数据:['驴 福 记 ( 阜 通 店 )','...',...]
    那执行vectorizer.fit_transform一定会报错:
    *** ValueError: empty vocabulary; perhaps the documents only contain stop words
    但是如果修改为
    ['驴 福 记 ( 阜通 店 )','...',...]
    执行vectorizer.fit_transform就正常。
    原因是,创建CountVectorizer实例时,有一个默认参数analyzer='word',在该参数作用下,词频矩阵构建过程会默认过滤所有的单字token,所以上面的'驴 福 记 ( 阜 通 店 )'以空格分隔以后全是单字,也就全被过滤了,所以就empty vocabulary了。

    如果想针对单字进行tfidf计算,可以加上参数vectorizer = CountVectorizer(analyzer='char'),此时,输入字符串无需做空格分隔, CountVectorizer会自动按照 单字 进行分隔统计词频。

    要想同时支持 字+词 的tfidf计算,需自定义token正则:
    vectorizer = CountVectorizer(analyzer='word',token_pattern=u"(?u)\\b\\w+\\b")



    展开全文
  • python计算tfidf

    千次阅读 2016-08-16 21:28:43
    本例来自mining social web from math import log # XXX: Enter in a query term from the corpus variable QUERY_TERMS = ['mr.', 'green'] def tf(term, doc, normalize=True): doc = doc.lower().split()

    本例来自mining social web

    from math import log
    
    # XXX: Enter in a query term from the corpus variable
    QUERY_TERMS = ['mr.', 'green']
    
    def tf(term, doc, normalize=True):
        doc = doc.lower().split()
        if normalize:
            return doc.count(term.lower()) / float(len(doc))
        else:
            return doc.count(term.lower()) / 1.0
    
    
    def idf(term, corpus):
        num_texts_with_term = len([True for text in corpus if term.lower()
                                  in text.lower().split()])
    
        # tf-idf calc involves multiplying against a tf value less than 0, so it's
        # necessary to return a value greater than 1 for consistent scoring. 
        # (Multiplying two values less than 1 returns a value less than each of 
        # them.)
    
        try:
            return 1.0 + log(float(len(corpus)) / num_texts_with_term)
        except ZeroDivisionError:
            return 1.0
    
    
    def tf_idf(term, doc, corpus):
        return tf(term, doc) * idf(term, corpus)
    
    
    corpus = \
        {'a': 'Mr. Green killed Colonel Mustard in the study with the candlestick. \
    Mr. Green is not a very nice fellow.',
         'b': 'Professor Plum has a green plant in his study.',
         'c': "Miss Scarlett watered Professor Plum's green plant while he was away \
    from his office last week."}
    
    for (k, v) in sorted(corpus.items()):
        print k, ':', v
    print
        
    # Score queries by calculating cumulative tf_idf score for each term in query
    
    query_scores = {'a': 0, 'b': 0, 'c': 0}
    for term in [t.lower() for t in QUERY_TERMS]:
        for doc in sorted(corpus):
            print 'TF(%s): %s' % (doc, term), tf(term, corpus[doc])
        print 'IDF: %s' % (term, ), idf(term, corpus.values())
        print
    
        for doc in sorted(corpus):
            score = tf_idf(term, corpus[doc], corpus.values())
            print 'TF-IDF(%s): %s' % (doc, term), score
            query_scores[doc] += score
        print
    
    print "Overall TF-IDF scores for query '%s'" % (' '.join(QUERY_TERMS), )
    for (doc, score) in sorted(query_scores.items()):
        print doc, score


    展开全文
  • 算法介绍最近要做领域概念的提取,...计算公式比较简单,如下: 预处理由于需要处理的候选词大约后3w+,并且语料文档数有1w+,直接挨个文本遍历的话很耗时,每个词处理时间都要一分钟以上。为了缩短时间,首先进行分...
  • 在sql下计算tfidf

    2017-12-05 08:42:00
    由于工作中要直接在sql中写tfidf,对tfidf又有了新的理解,以及又让我厌恶了sql。。。因为在R或者python中写起tfidf来还是很方便的,直接调个包,或者直接写都很快,但在sql中写起来有点慢,比较冗长,也有可能我写...
  • 本例来自mining social webfrom math import log# XXX: Enter in a query term from the corpus variableQUERY_TERMS = ['mr.', 'green']def tf(term, doc, normalize=True):doc = doc.lower().split()if normalize:...
  • tfidfkdong文本分词后利用tfidf算法计算每个文档的tfidf值,以便后期跑实验使用1.读取文件夹下的文档并分词readFile方法:读取所有文件夹下的文件路径,返回一个list文件路径列表readContent方法:将一个文档中的...
  • # **最后是实际计算商品间相似度的程序三,这个用LSI模型来比对的话,2k行要跑四五十分钟,但我的数据量有50w。用tfidf模型来算直接报memory error 不给跑** ``` Python # -*- coding: utf-8 -*- import logging,...
  • 展开全部//直接粘贴就行。import java.awt.BorderLayout;import java.awt.EventQueue;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.io.File;import java.io.IOException;...
  • 5、计算tfidf TFIDF=tF* iDF tFIDF_DF =pandas.DataFrame(TFIDF) 6、将每个文本中tfidf值排名前100的词和相应的tfidf值输出 file= [] for root ,dirs,files in os.walk(r ' H:\19113117 - 副本 ' ):...
  • 写在前面的话,既然是学习版本,那么就不是一个好用的工程实现版本,整套代码全部使用List进行匹配效率可想而知。 【原文转自】:... P.S:如果不是被迫需要语言统一,尽量不要使用此工程计算TF-IDF,...
  • public function get_tfidf($txt){ $word_ret = array(); $this->analysis->send_text($txt); $total = 0; while($result = $this->analysis->get_result()){ $total++; foreach($result as $v){ ...
  • transformer=TfidfTransformer()#该类会统计每个词语的tf-idf权值 tfidf=transformer.fit_transform(vectorizer.fit_transform(corpus))#第一个fit_transform是计算tfidf,第二个是将文本转化为词频矩阵 word=...
  • //存储所有文本行以及每一行各个单词出现次数,用于计算TF vector< vector<double> > aaLinesTf; //所有文本行对应所有单词的TF*IDF map,int> mKeyAprLines; //每个单词在多少行里出现过,用于计算IDF vector...
  • Tfidf计算

    2020-07-25 13:54:14
    Tfidf计算 主要内容 读取全部评论与词频构成的xls文档 读取对评论初步分词后的文档和停用词txt文档 将每条评论的词汇与词频输出为字典形式,同时每条评论整体输出为一个列表元素(方便后续构造稀疏矩阵) 计算各...
  • 摘要这篇文章主要介绍了计算TF-IDF的不同方法实现,主要有三种方法:用gensim库来计算tfidf值用sklearn库来计算tfidf值用python手动实现tfidf的计算关于TFIDF的算法原理我就不过多介绍了,看这篇博客即可——TF-IDF...
  • 在Hadoop集群中,用MapReduce分布式计算TFIDF
  • Tfidf词频计算

    2015-05-28 00:26:09
    基于tf idf的文档集关键词提取 已经含有测试文档集 可以替换成任意需要的文档集 可以自己提供字典
  • 基于MR实现的TFIDF相似度的计算过程,可以深刻理解mapreducer的过程同时了解TFIDF计算过程
  • TFIDF

    2019-09-14 16:25:20
    目录1.TFIDF算法原理2. TFIDF 概率模型解释3. TFIDF python 实战 1.TFIDF算法原理 TFIDF (term frequency - inverse document frequency) 主要思想:如果某个词或者短语在...计算公式: 有语料库DDD,文章表示为 d...
  • tfidf+cos.py

    2020-04-09 15:03:07
    读取82个txt文件,文本预处理,计算tfidf值,将矩阵导出excel,获取词袋,将词袋写入excel,计算余弦相似度并导出excel
  • 做数据挖掘的最常见的就是要对文档向量化,而向量化表示中最常见的...本文讲解一下使用Hadoop计算TFIDF值的步骤,在其它地方也有不少这方面的介绍,本文仅供参考。 在本地进行TFIDF计算需要三步:1. 统计数据集中独
  • 使用sklearn实现tfidf特征计算

    千次阅读 2017-08-22 15:40:24
    sklearn实现tfidf特征计算
  • 本文主要参考https://stackoverflow.com/questions/12118720/python-tf-idf-cosine-to-find-document-similaritStackOverflow的回答主要是使用sklearn的TfidfTransformercosine_similarity就是计算L2归一化的向量...
  • Python TFIDF计算文本相似度

    千次阅读 2020-02-02 22:25:28
    本文主要参考https://stackoverflow.com/questions/12118720/python-tf-idf-cosine-to-find-document-similaritStackOverflow的...cosine_similarity就是计算L2归一化的向量点乘。如果x,y是行向量,它们的cosine sim...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 436
精华内容 174
关键字:

计算tfidf