精华内容
下载资源
问答
  • TFIDF

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


    1.TFIDF算法原理

    TFIDF (term frequency - inverse document frequency)
    主要思想:如果某个词或者短语在一篇文章中出现的频率TF较高,而且在其他文章中出现的频率较少,则认为此词或短语具有很好的类别区分能力。

    计算公式:
    有语料库DD,文章表示为 dd,文章中的词或者短语表示为ww
    TF(term frequency,词频):
    TFw,di=count(w)tdicount(t) TF_{w, d_i} = \frac{count(w)} {\sum\limits_{t \in d_i} count(t)}

    count(w)count(w)为关键词ww出现的次数。

    IDF(inverse document frequency, 逆文档频率):
    IDFw,D=logD1+i=1DI(w,di) IDF_{w, D} = log \frac{|D|} {1 + \sum\limits_{i = 1}^{|D|} I(w, d_i) }
    D|D|表示语料库DD中文章的数量,I(w,di)I(w, d_i)为指示函数,表示词或者短语ww是否在文章did_i中出现,出现为1,否则为0。
    若词或者短语ww未在语料库中出现过,我们需要对IDFIDF进行平滑(smooth)操作。

    TFIDFw,di=TFw,diIDFw,D TFIDF_{w, d_i} = TF_{w, d_i} * IDF_{w, D}


    一些结论:

    1. 当一个词在文章频率越高并且新鲜度高(即普遍度低),其TF-IDF值越高。
    2. TF-IDF兼顾词频与新鲜度,过滤一些常见词,保留能提供更多信息的重要词。


    2. TFIDF 概率模型解释

    参考网页


    3. TFIDF python 实战

    参考网页

    展开全文
  • Java实现TFIDF算法

    2019-09-27 23:00:22
    算法介绍 最近要做领域概念的提取,TFIDF作为一个很经典的算法...计算公式比较简单,如下: 预处理 由于需要处理的候选词大约后3w+,并且语料文档数有1w+,直接挨个文本遍历的话很耗时,每个词处理时间都要一...

    算法介绍

    最近要做领域概念的提取,TFIDF作为一个很经典的算法可以作为其中的一步处理。

    关于TFIDF算法的介绍可以参考这篇博客http://www.ruanyifeng.com/blog/2013/03/tf-idf.html

    计算公式比较简单,如下:

     

    预处理

    由于需要处理的候选词大约后3w+,并且语料文档数有1w+,直接挨个文本遍历的话很耗时,每个词处理时间都要一分钟以上。

    为了缩短时间,首先进行分词,一个词输出为一行方便统计,分词工具选择的是HanLp。

    然后,将一个领域的文档合并到一个文件中,并用“$$$”标识符分割,方便记录文档数。

    下面是选择的领域语料(PATH目录下):

    代码实现

    package edu.heu.lawsoutput;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * @ClassName: TfIdf
     * @Description: TODO
     * @author LJH
     * @date 2017年11月12日 下午3:55:15
     */
    
    public class TfIdf {
    
        static final String PATH = "E:\\corpus"; // 语料库路径
    
        public static void main(String[] args) throws Exception {
    
            String test = "离退休人员"; // 要计算的候选词
    
            computeTFIDF(PATH, test);
    
        }
    
        /**
        * @param @param path 语料路经
        * @param @param word 候选词
        * @param @throws Exception 
        * @return void 
        */
        static void computeTFIDF(String path, String word) throws Exception {
    
            File fileDir = new File(path);
            File[] files = fileDir.listFiles();
    
            // 每个领域出现候选词的文档数
            Map<String, Integer> containsKeyMap = new HashMap<>();
            // 每个领域的总文档数
            Map<String, Integer> totalDocMap = new HashMap<>();
            // TF = 候选词出现次数/总词数
            Map<String, Double> tfMap = new HashMap<>();
    
            // scan files
            for (File f : files) {
    
                // 候选词词频
                double termFrequency = 0;
                // 文本总词数
                double totalTerm = 0;
                // 包含候选词的文档数
                int containsKeyDoc = 0;
                // 词频文档计数
                int totalCount = 0;
                int fileCount = 0;
                // 标记文件中是否出现候选词
                boolean flag = false;
    
                FileReader fr = new FileReader(f);
                BufferedReader br = new BufferedReader(fr);
                String s = "";
    
                // 计算词频和总词数
                while ((s = br.readLine()) != null) {
                    if (s.equals(word)) {
                        termFrequency++;
                        flag = true;
                    }
    
                    // 文件标识符
                    if (s.equals("$$$")) {
                        if (flag) {
                            containsKeyDoc++;
                        }
                        fileCount++;
                        flag = false;
                    }
                    totalCount++;
                }
    
                // 减去文件标识符的数量得到总词数
                totalTerm += totalCount - fileCount;
                br.close();
                // key都为领域的名字
                containsKeyMap.put(f.getName(), containsKeyDoc);
                totalDocMap.put(f.getName(), fileCount);
                tfMap.put(f.getName(), (double) termFrequency / totalTerm);
    
                System.out.println("----------" + f.getName() + "----------");
                System.out.println("该领域文档数:" + fileCount);
                System.out.println("候选词出现词数:" + termFrequency);
                System.out.println("总词数:" + totalTerm);
                System.out.println("出现候选词文档总数:" + containsKeyDoc);
                System.out.println();
            }
            
            //计算TF*IDF
            for (File f : files) {
    
                // 其他领域包含候选词文档数
                int otherContainsKeyDoc = 0;
                // 其他领域文档总数
                int otherTotalDoc = 0;
    
                double idf = 0;
                double tfidf = 0;
                System.out.println("~~~~~" + f.getName() + "~~~~~");
    
                Set<Map.Entry<String, Integer>> containsKeyset = containsKeyMap.entrySet();
                Set<Map.Entry<String, Integer>> totalDocset = totalDocMap.entrySet();
                Set<Map.Entry<String, Double>> tfSet = tfMap.entrySet();
    
                // 计算其他领域包含候选词文档数
                for (Map.Entry<String, Integer> entry : containsKeyset) {
                    if (!entry.getKey().equals(f.getName())) {
                        otherContainsKeyDoc += entry.getValue();
                    }
                }
    
                // 计算其他领域文档总数
                for (Map.Entry<String, Integer> entry : totalDocset) {
                    if (!entry.getKey().equals(f.getName())) {
                        otherTotalDoc += entry.getValue();
                    }
                }
    
                // 计算idf
                idf = log((float) otherTotalDoc / (otherContainsKeyDoc + 1), 2);
    
                // 计算tf*idf并输出
                for (Map.Entry<String, Double> entry : tfSet) {
                    if (entry.getKey().equals(f.getName())) {
                        tfidf = (double) entry.getValue() * idf;
                        System.out.println("tfidf:" + tfidf);
                    }
                }
            }
        }
    
        static float log(float value, float base) {
            return (float) (Math.log(value) / Math.log(base));
        }
    }            

    运行结果 

    测试词为“离退休人员”,中间结果如下:

     最终结果:

    结论

    可以看到“离退休人员”在养老保险和社保领域,tfidf值比较高,可以作为判断是否为领域概念的一个依据。

    当然TF-IDF算法虽然很经典,但还是有许多不足,不能单独依赖其结果做出判断。

    很多论文提出了改进方法,本文只是实现了最基本的算法。

    如果有其他思路和想法欢迎讨论。


    转载请注明原文链接:http://www.cnblogs.com/justcooooode/p/7831157.html

    转载于:https://www.cnblogs.com/justcooooode/p/7831157.html

    展开全文
  • java 实现tfidf

    2011-06-14 20:38:29
    针对文本分类而言 作为很简单的说明,特征选择都跟 类别有关比如 卡方 信息增益 而权重计算则与类别无关 比如 tfidf,tf 具体公式请参看 http://zh.wikipedia.org/wiki/TF-IDF 下面代码 写的比较粗陋。高手请避开。...

    tfidf 做自然语言理解的经常用。文档的作为权重计算,
    许多初学者搞不清楚,权重计算特征选择。
    针对文本分类而言 作为很简单的说明,特征选择都跟 类别有关比如 卡方 信息增益
    而权重计算则与类别无关 比如 tfidf,tf
    具体公式请参看 http://zh.wikipedia.org/wiki/TF-IDF
    下面代码 写的比较粗陋。高手请避开。,,,,,
    训练集可以上搜狗数据集上下载

    写完以后感觉还是matlab 比较爽啊。。几行 解决java100多行的代码

     

    public class TfIdfcomputor {
    	static String path = "E:\\训练集\\train\\";
    	static String  vsmpath = "E:\\训练集\\vsm\\vsm.txt";
    	//static String path = "E:\\训练集\\SogouC.reduced\\Reduced";
       // static String path ="E:\\训练集\\SogouC.mini\\Sample";
    	static Map<String, Map<String, Double>> DFdic = new HashMap();
    	static HashMap<String, List<Map<String, Double>>> dic = new HashMap();
    	static int DCOUNT;
    	static HashMap<String, Double> idfDic = new HashMap();
    	 static      Map<String, Map<String,Double>> TFIDFdic = new HashMap();
    	// static Map<String,List<String>> Simpledic= new HashMap();
    	public static void main(String[] args) throws IOException {
    
    		TfIdfcomputor tf = new TfIdfcomputor();
    		File[] Filelist = tf.readData(path);
    		DCOUNT = Filelist.length;
    		tf.readir(Filelist);
    		System.out.println("DFdic");
    	
    		tf.computeIDF(dic);
            tf.ComputeTFIDF(); 
          /* for( String s :TFIDFdic.keySet())
            {
             Map map  = TFIDFdic.get(s);
             for(Object key :map.keySet() )
             {
            	 System.out.println("file "+s +"word "+ key+" tfidf "+map.get(key));
            	 
             }
            	
            
            }*/
            
       System.out.println("计算完毕开始输出");
       tf.toLibData();
    }
    
    	public void readir(File[] dir) throws IOException {
    
    		File[] fileList = dir;
    		for(File f :fileList){
    			System.out.println(f.getPath());
    		}
    
    		for (int i = 0; i < fileList.length; i++) {
    			File f = fileList[i];
    			//System.out.println(f.getPath());
    			String[] textword = cutWord(FiletoText(f.getPath()));
    			Map tf = computeTf(textword);
    			DFdic.put(f.getPath(), tf);
    			addDic(f.getPath(), tf);
    		}
    
    		System.out.println("TF PROCESS IS OVER");
    
    		System.out.println(dic.size());
    		for (Object o : dic.keySet()) {
    			System.out.println(o);
    			List list = dic.get(o);
    			for (Object l : list) {
    				Map pair = (Map) l;
    				for (Object p : pair.keySet()) {
    				/*	System.out.println("key" + (String) o + "..."
    							+ "filepath...." + p + "tf..." + pair.get(p));*/
    				}
    
    			}
    
    		}
    
    	}
    
    	public String FiletoText(String path) throws IOException {
    		File f = new File(path);
    		BufferedReader br = new BufferedReader(new InputStreamReader(
    				new FileInputStream(f), "GB2312"));
    		String result = "";
    		String temp;
    		while ((temp = br.readLine()) != null) {
    			result = result + temp;
    		}
    		br.close();
    		return result;
    	}
    
    	public String[] cutWord(String text) throws IOException {
    		MMAnalyzer analyzer = new MMAnalyzer();
    		String temp = analyzer.segment(text, "|");
    		//System.out.println(temp);
    		String[] result = temp.split("\\|");
    		/*
    		 * for(String s :result ) { System.out.println(s); }
    		 */
    		return result;
    	}
    
    	public HashMap<String, Double> computeTf(String[] textword) {
    		double size = textword.length;
    		HashMap<String, Integer> map = new HashMap();
    		for (int i = 0; i < textword.length; i++) {
    			//System.out.println(textword[i]);
    			if (map.containsKey(textword[i])) {
    				Integer count = map.get(textword[i]);
    
    				map.put(textword[i], count + 1);
    
    			} else {
    				map.put(textword[i], 1);
    			}
    
    		}
    
    		HashMap<String, Double> result = new HashMap();
    		for (Object o : map.keySet()) {
    			Integer temp = map.get(o);
    
    			//System.out.println((String) o + "count..." + temp);
    			result.put((String) o, temp / size);
    			//System.out.println((String) o + "tf..." + result.get(o));
    
    		}
    
    		return result;
    
    	}
    
    	public void addDic(String path, Map tf) {
    		//System.out.println(",,,,,,,,,,,,,");
    		for (Object o : tf.keySet()) {
    			if (dic.containsKey((String) o)) {
    
    				ArrayList list = (ArrayList) dic.get(o);
    				HashMap map = new HashMap();
    				map.put(path, (Double) tf.get((String) o));
    				list.add(map);
    				dic.put((String) o, list);
    			} else {
    				HashMap map = new HashMap();
    				map.put(path, (Double) tf.get((String) o));
    				ArrayList list = new ArrayList<Map<String, Double>>();
    				list.add(map);
    				dic.put((String) o, list);
    			}
    
    		}
    
    	}
    
    	public static File[] readData(String path) {
    		int size = 0;
    		File[] floderdir = new File(path).listFiles();
    		ArrayList list = new ArrayList();
    		for (File f : floderdir) {
    			// size = size+(int)f.length();
    			File[] childdir = f.listFiles();
    			for (File file : childdir) {
    				list.add(file);
    
    			}
    		}
    		size = list.size();
    		File[] fdir = new File[size];
    		for (int i = 0; i < size; i++) {
    			fdir[i] = (File) list.get(i);
    
    		}
    
    		return fdir;
    
    	}
    
    	public void computeIDF(HashMap<String, List<Map<String, Double>>> map) {
    
    		for (String key : map.keySet()) {
    			List list = map.get(key);
    			double hasCount = (double) list.size();
    			double idf = DCOUNT / hasCount;
    
    			idfDic.put(key, idf);
    		}
    
    	}
    
    	public void ComputeTFIDF() {
    		
    		for (String filepath : DFdic.keySet()) {
    			Map filedic = DFdic.get(filepath);
    			HashMap<String, Double> tfidfPair = tfidfPair = new HashMap();
    			for (Object key : filedic.keySet()) {
    				 
    				double tf = (Double) filedic.get(key);
    
    				double idf = idfDic.get((String) key);
    				double tfidf = tf* Math.log(idf);
    			//	System.out.println( key+"tf" + tf + "idf" + idf + "tfidf" + tfidf);
                    tfidfPair.put((String) key, tfidf);
    			}
    		//	System.out.println(tfidfPair.size());
                TFIDFdic.put(filepath, tfidfPair);
    		}
    
    	}
    
    	
    	public void toLibData() throws IOException// 转化成libsvm格式;
    
    	{
    		int count = 0;
    		// int size =dic.entrySet().size();
    		List wordList = new ArrayList();
    		for (String word : dic.keySet()) {
    			wordList.add(word);
    			System.out.println("worddic add" + word);
    		}
    		// System.out.println("total word is"+wordList.size());
    		BufferedWriter bw = new BufferedWriter(
    				new FileWriter(new File(vsmpath)));
    		/*
    		 * String [] wordList = new String[size]; int num=0; for(String word:
    		 * dic.keySet()) { wordList[num]=word; num++;
    		 * System.out.println("worddic add"+word); }
    		 */
    		String vsm = "";
    		for (String filename : TFIDFdic.keySet()) {
    			String lable = new File(filename).getParentFile().getName();
    			Map map = TFIDFdic.get(filename);// 获取某片文章对应的tfidf
    			vsm = vsm + lable + " ";
    			for (int i = 0; i < wordList.size(); i++) {
    
    				// System.out.println( "map.."+ map.size());
    
    				// String temp =wordList[i];
    				// System.out.println("temp"+ temp);
    				String temp = (String) wordList.get(i);
    				if (map.containsKey(temp)) {
    					vsm = vsm + i + ":" + map.get(temp) + " ";
    					// System.out.println(filename + "...." + temp + "...."+
    					// map.get(temp) + "...");
    				}
    			}
    			count++;
    			vsm = vsm + "\n";
    			bw.write(vsm);
    			vsm = "";
    			System.out.println("format" + "  " + count + " " + filename);
    		}
    		System.out.println("begin output");
    		// BufferedWriter bw = new BufferedWriter(new FileWriter(new
    		// File(vsmpath)));
    		// bw.write(vsm);
    		System.out.println(".............................");
    		// System.out.println(vsm);
    		bw.close();
    
    	}
    }
    

     

    展开全文
  • python 基于标签的推荐Tag-based及SimpleTagBased、TagBased-TFIDF等算法实现...based2.2.1 计算公式2.3 Norm Tag-based2.3.1 计算公式2.4 Tag-based TFIDF2.4.1 计算公式3. 代码实现3.1 数据介绍3.2 基于pandas datafr

    1. 概览

    本篇主要介绍关于推荐算法相关的知识:基于标签的推荐,涉及了3个原理较简单的计算方法(Simple Tag-based、Normal Tag-based、Tag-based-Tfidf ),以及基于pandas dataframe的python代码实现。

    dataframe的效率比用字典实现低很多,主要是因为该算法涉及到较多的取值操作,字典的取值的平均时间复杂度当然要比dataframe用loc快很多。

    2. 基本概念

    2.1 用户画像

    2.1.1 定义

    用户画像毋庸置疑,即是对用户行为特征的总结归纳和描述,以更好的提升业务质量。

    2.1.2 步骤
    1. 定义全局的用户唯一标识id(例如身份证、手机号、用户id等)
    2. 给用户打标签
    3. 根据标签为为业务带来不同阶段的收益。在用户生命周期的3个阶段:获客、粘客、留客 中,根据各类的用户数据对用户进行标签化、用户画像等,尽最大限度对用户进行留存。
    2.1.3 标签来源
    1. PGC:通过工作人员进行打标签(质量高,数据规范)

      通过聚类算法对物品进行降为形成不同的标签。物品的标签化,本身是对物品的降维,所以可以利用聚类、降维的方法进行物品标签的生成。目前主流的聚类方法有:Kmeans,EM,DBScan,层级聚类,PCA等等。

    2. UGC:通过用户进行打标签(质量低,数据不规范)

    2.1.4 标签相关的数据结构
    • 用户打标签的记录【user_id, item_id, tag】
    • 用户打过的标签【user_id, tag】
    • 用户打过标签的item【user_id, item】
    • 打上某标签的item【tag, item】
    • 同样打过某标签的用户【tag, user_id】
    2.1.5 如何给用户推荐标签

    根据用户的标签行为数据,通过SimpleTagBased 、 NormTagBased 及 TagBased-TFIDF 等方法,当用户A给某item打了标签T,进行以下4种类型的推荐:

    • 给用户A推荐系统中热门标签的item

    • item上有热门的标签T-hot,给用户A推荐其他打了T-hot标签的items

    • 用户自己经常对不同item打上标签T1等,对同样有T1标签的其他item进行推荐

    • 将以上几种进行融合。

    2.2 Simple Tag-based

    2.2.1 计算公式

    score(u,i)=tuser_tags[u,t]tag_items[t,i] score(u, i)=\sum_t{user\_tags[u, t] * tag\_items[t, i]}

    其中 user_tags[u,t] 表示【用户u使用标签t的次数】,tag_items[t, i] 表示【物品i被打上标签t的次数】

    2.3 Norm Tag-based

    2.3.1 计算公式

    score(u,i)=tuser_tags[u,t]user_tags[u]tag_items[t,i]tag_items[t] score(u,i)=\sum_t{\frac{user\_tags[u, t]}{user\_tags[u]} * \frac{tag\_items[t, i]}{tag\_items[t]}}

    其中 user_tags[u] 表示【用户u打标签的总次数】,tag_items[t] 表示【标签t被使用的总次数】

    2.4 Tag-based TFIDF

    2.4.1 计算公式

    score(u,i)=tuser_tags[u,t]log(1+tag_users[t])tag_items[t,i] score(u,i)=\sum_t{\frac{user\_tags[u, t]}{log(1 + tag\_users[t])} * tag\_items[t, i]}

    其中 tag_users[t] 表示【标签t被用户使用的总次数】

    3. 代码实现

    3.1 数据介绍

    在这里插入图片描述
    标准的userID -> bookmarkID -> tagID 记录行数据

    3.2 基于pandas dataframe的标签推荐

    3.2.1 python代码
    # -*- coding: utf-8 -*-
    """
    Created on 2020/11/18 13:54
    
    @author: Irvinfaith
    
    @email: Irvinfaith@hotmail.com
    """
    import operator
    import time
    import random
    import pandas as pd
    import numpy as np
    
    class TagBased(object):
        def __init__(self, data_path, sep='\t'):
            self.data_path = data_path
            self.sep = sep
            self.calc_result = {}
            self.table = self.__load_data(data_path, sep)
    
        def __load_data(self, data_path, sep):
            table = pd.read_table(data_path, sep=sep)
            return table
    
        def __calc_frequency(self, table):
            # user -> item
            user_item = table.groupby(by=['userID','bookmarkID'])['tagID'].count()
            # user -> tag
            user_tag = table.groupby(by=['userID', 'tagID'])['bookmarkID'].count()
            # tag -> item
            tag_item = table.groupby(by=['tagID', 'bookmarkID'])['userID'].count()
            # tag -> user
            tag_user = table.groupby(by=['tagID', 'userID'])['bookmarkID'].count()
            return {"user_item": user_item, "user_tag": user_tag, "tag_item": tag_item, "tag_user": tag_user}
    
        def train_test_split(self, ratio, seed):
            return self.__train_test_split(self.table, ratio, seed)
    
        def __train_test_split(self, table, ratio, seed):
            random.seed(seed)
            t1 = time.time()
            stratify_count = table.groupby(by='userID')['userID'].count()
            stratify_df = pd.DataFrame({"count":stratify_count})
            stratify_df['test_num'] = (stratify_df['count'] * ratio ).apply(int)
            test_id = []
            train_id = []
            """
            ==========================================
            # 方法 1:dataframe的iterrows遍历行
            # 10次执行平均耗时约 2.3秒
            ==========================================
            # for index, row in stratify_df.iterrows():
            #     tmp_ids = table[table['userID'] == index].index.tolist()
            #     tmp_test_id = random.sample(tmp_ids, row['test_num'])
            #     test_id.extend(tmp_test_id)
            #     train_id.extend(list(set(tmp_ids) -set(tmp_test_id)))
    
            ==========================================
            # 方法 2:series map和dataframe apply
            # 10次执行平均耗时约 2.2秒
            ==========================================
            按理来说,apply + map会比 iterrows 快很多,可能下面这个写法存储了较多的list,主要是为了方便查看拆分的结果,
            所以在遍历取数的时候会花费更多的时间。
            虽然apply+map方法只比iterrows快了0.1秒左右,但是在写法上我还是喜欢用apply+map。
            """
            stratify_df['ids'] = stratify_df.index.map(lambda x: table[table['userID'] == x].index.tolist())
            stratify_df['test_index'] = stratify_df.apply(lambda x: random.sample(x['ids'], x['test_num']), axis=1)
            stratify_df['train_index'] = stratify_df.apply(lambda x: list(set(x['ids']) - set(x['test_index'])), axis=1)
            stratify_df['test_index'].apply(lambda x: test_id.extend(x))
            stratify_df['train_index'].apply(lambda x: train_id.extend(x))
            train_data = table.iloc[train_id].reset_index(drop=True)
            test_data = table.iloc[test_id].reset_index(drop=True)
            print("Split train test dataset by stratification, time took: %.4f" % (time.time() - t1))
            return {"train_data": train_data, "test_data": test_data}
    
        def __calc_item_recommendation(self, user_id, user_item, user_tag, tag_item, n, method):
            marked_item = user_item[user_id].index
            recommend = {}
            # t1 = time.time()
            # user_id -> tag -> item -> count
            marked_tag = user_tag.loc[user_id]
            marked_tag_sum = marked_tag.values.sum()
            for tag_index, tag_count in marked_tag.iteritems():
                selected_item = tag_item.loc[tag_index]
                selected_item_sum = selected_item.values.sum()
                tag_selected_users_sum = self.calc_result['tag_user'].loc[tag_index].values.sum()
                for item_index, tag_item_count in selected_item.iteritems():
                    if item_index in marked_item:
                        continue
                    if item_index not in recommend:
                        if method == 'norm':
                            recommend[item_index] = (tag_count / marked_tag_sum) * (tag_item_count / selected_item_sum)
                        elif method == 'simple':
                            recommend[item_index] = tag_count * tag_item_count
                        elif method == 'tfidf':
                            recommend[item_index] = tag_count / np.log(1 + tag_selected_users_sum) * tag_item_count
                        else:
                            raise TypeError("Invalid method `{}`, `method` only support `norm`, `simple` and `tfidf`".format(method))
                    else:
                        if method == 'norm':
                            recommend[item_index] += (tag_count / marked_tag_sum) * (tag_item_count / selected_item_sum)
                        elif method == 'simple':
                            recommend[item_index] += tag_count * tag_item_count
                        elif method == 'tfidf':
                            recommend[item_index] += tag_count / np.log(1 + tag_selected_users_sum) * tag_item_count
                        else:
                            raise TypeError("Invalid method `{}`, `method` only support `norm`, `simple` and `tfidf`".format(method))
            # print(time.time() - t1)
            sorted_recommend = sorted(recommend.items(), key=lambda x: (x[1]), reverse=True)[:n]
            return {user_id: dict(sorted_recommend)}
    
        def __eval(self, train_recommend, test_data):
            user_id = [i for i in train_recommend.keys()][0]
            test_data_item = test_data['bookmarkID'].unique()
            tp = len(set(test_data_item) & set(train_recommend[user_id].keys()))
            # for item_id in test_data_item:
            #     if item_id in train_recommend[user_id]:
            #         tp += 1
            return tp
    
        def fit(self, train_data):
            self.calc_result = self.__calc_frequency(train_data)
    
        def predict(self, user_id, n, method='simple'):
            return self.__calc_item_recommendation(user_id,
                                                   self.calc_result['user_item'],
                                                   self.calc_result['user_tag'],
                                                   self.calc_result['tag_item'],
                                                   n,
                                                   method)
    
        def eval(self, n, test_data):
            t1 = time.time()
            test_data_user_id = test_data['userID'].unique()
            total_tp = 0
            tpfp = 0
            tpfn = 0
            check = []
            for user_id in test_data_user_id:
                train_recommend = self.predict(user_id, n)
                user_test_data = test_data[test_data['userID'] == user_id]
                total_tp += self.__eval(train_recommend, user_test_data)
                tpfn += len(user_test_data['bookmarkID'].unique())
                tpfp += n
                check.append((user_id, total_tp, tpfn, tpfp))
            recall = total_tp / tpfn
            precision = total_tp / tpfp
            print("Recall: %10.4f" % (recall * 100))
            print("Precision: %10.4f" % (precision * 100))
            print(time.time() - t1)
            return recall, precision, check
    
    if __name__ == '__main__':
        file_path = "user_taggedbookmarks-timestamps.dat"
        tb = TagBased(file_path, '\t')
        train_test_data = tb.train_test_split(0.2, 88)
        tb.fit(train_test_data['train_data'])
        calc_result = tb.calc_result
        # 使用3种方法,预测用户id为8 的排序前10的item
        p1_simple = tb.predict(8, 10)
        p1_tf = tb.predict(8, 10, method='tfidf')
        p1_normal = tb.predict(8, 10, method='norm')
    
    
    3.2.2 结果展示

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • java实现 tfidf

    2014-10-28 11:23:48
    tfidf 做自然语言理解的经常用。文档的作为权重计算, 许多初学者搞不清楚,权重计算特征选择。 针对文本分类而言 作为很简单的说明...而权重计算则与类别无关 比如 tfidf,tf 具体公式请参看 http://zh.wikipedia.org
  • 算法介绍 最近要做领域概念的提取,TFIDF作为一个很经典的算法可以作为其中的一步处理。...计算公式比较简单,如下: 预处理 由于需要处理的候选词大约后3w+,并且语料文档数有1w+,直接挨个文本遍历的话很耗时...
  • 计算公式: TF=某个词在文档中出现的次数文档的总词数TF = \frac{某个词在文档中出现的次数}{文档的总词数}TF=文档的总词数某个词在文档中出现的次数​ 某个词出现越多,表示它约重要。 某个词越少见,就越能...
  • BM25算法Best Matching

    2020-10-20 22:17:43
    不同与TFIDF, BM25 的公式主要由三部分组成: query 中每个单词t与文档d之间的相关性 单词t与query之间的相似性 每个单词的权重 BM25 带来的好处: BM25 vs TFIDF BM25公式 BM25的一般公式: (计算query Q与某个文档...
  • 默认的实现还是基于经典的TFIDF模型。下面对solr edismax查询中涉及到的一些公式进行介绍。   tf(float freq):词频,freq为某个词在该文档的相应field中出现的次数, 默认为Math.sqrt(freq): idf(long docFreq...
  • 将BM25 用作lucene排序算法的实现步骤

    千次阅读 2011-08-02 19:40:47
    BM25算法的介绍:... BM25算法一直是被用作代替lucene的TFIDF的评分公式的。 首先给出BM25的相关度计算公式,该函数可以计算出对于一个document,一个给定的关键字序列i对于该do
  • VSTO 两个实例

    2014-04-29 11:09:11
    实验环境:VS2013+Office2013。所用语言C# 两个VSTO开发实例 Task1——行求和,然后画出曲线图 随机生成100行100列个数,每个数位为0~9的整数,然后...算TFIDF公式有几个变种(参考wikipedia),自己用了最简单的。
  • 如果你曾经为网站做过单词或短语分析以便获得更好的搜索排名,你会对SSIS...这个统计值可以是该关键词出现的次数,也可以是使用稍微复杂一点的计算公式TFIDF)计算得出的几率值。缩写词TFIDF的全称是Term Frequenc...
  • TF和IDF

    2013-05-07 09:50:38
    用下面的tfidf函数来计算单词w的权重weight(w)=TF*IDF=TF*lg[|D|/DF(w)],其中词频TF为单词w在该文本中出现的次数,|D|代表训练集中文本总数,DF(w)为出现了w的文档数,而IDF=lg[|D|/DF(w)]称为逆文本频数.该算法又称为...
  • # 定义计算tfidf公式的函数 # count[word]可以得到每个单词的词频, sum(count.values())得到整个句子的单词总数 def tf(word, count): return count[word] / sum(count.values()) # 统计的是含有该单词的句子数 ...
  • NLP TASK3 特征选择

    2019-05-16 10:42:00
    任务描述: TF-IDF原理以及利用其进行特征筛选 互信息的原理以及利用其进行特征筛选 TFIDF原理简介 ...计算公式 TF=某个单词在文章出现的次数文章的总词汇TF=\frac{某个单词在文章出现的次数}{文章...
  • NLP入门(二)探究TF-IDF的原理

    千次阅读 2018-11-02 11:40:50
    TF-IDF介绍   TF-IDF是NLP中一种常用的统计方法,用以评估一个字词对于一个文件集或一个语料库中的其中一份文件的...  在NLP中,TF-IDF的计算公式如下: tfidf=tf∗idf.tfidf = tf*idf.tfidf=tf∗idf. 其中,...
  • 一,TF-IDF介绍 1,TF-IDF简介    TF-IDF是NLP中一种常用的统计方法,用...2,TF-IDF的计算公式 在NLP中,TF-IDF的计算公式如下: tfidf = tf*idf. 其中,tf是词频(Term Frequency),idf为逆向文件频率(Inverse Do
  • 2011年06月20日

    2014-10-28 11:23:50
    tfidf 做自然语言理解的经常用。文档的作为权重计算, 许多初学者搞不清楚,权重计算特征选择。 针对文本分类而言 作为很简单的说明...而权重计算则与类别无关 比如 tfidf,tf 具体公式请参看 http://zh.wikipedia.org
  • 1 TF-IDF的计算公式 TF-IDF的主要思想是:如果某个词或短语在一篇文章中出现的频率TF高,并且在其他文章中很少出现,则认为此词或者短语具有很好的类别区分能力,适合用来分类。TFIDF实际上是:TF * IDF,TF词频...
  • 新闻分类

    2012-11-30 21:01:11
    标题tfidf正文tfidf单词首次出现的位置,计算公式为log(|D|/first_pos),(我试过|D|/first_pos,不过效果不理想) 分类器我采用了线性的SVM,训练测试集是从sina, sohu, qq, 163, ifeng, people,
  • 中文意思是关键词抽取,用于...TFIDF的全称是Term Frequency and Inverse Document Frequency,是一个用于计算单词或词组在在整个文本中出现的几率。下面是这个公式的表达式: TDIDF (of a term or phrase) = (fre...
  • NLP分类

    2018-10-08 19:30:00
    NLP目前主要的技术: 1、分类算法:SVM、朴素贝叶斯、K近邻、决策树、集成学习(原理和应用) 2、聚类算法:kmeans、层次聚类、密度聚类(原理和应用) 3、概率图模型HMM、CRF(原理和应用)...8、距离计算公式...
  • 计算公式tfidf=tf∗idftfidf = tf* idftfidf=tf∗idf 前者是词频后者是逆向文件频率。 tf=i/N tf = i/N tf=i/N idef=log2(nk) idef=log_2(\frac{n}{k}) idef=log2​(kn​) 其中k可以加上1以避免分母为0。 实现也...
  • tf_idf

    2019-08-14 19:24:05
    TF-IDF TF-IDF(Term Frequency-InversDocument Frequency)是一种常用于信息处理和数据挖掘的加权技术。该技术采用一种统计方法,根据字词的在文本中出现的次数和在...计算方法如下面公式所示。 其中,式中tfidf...
  • 如果没有数据的时候,那只能通过正则或者规则来解决问题 ...接着计算相似度,给定两个向量计算相似度 根据相似度进行排序,排序后返回结果 NLP的项目流程 分词 分词工具 最常用的还是jieba,中文分词工

空空如也

空空如也

1 2
收藏数 34
精华内容 13
关键字:

tfidf计算公式