标签: tf-idf

我想规范化我从这个给定代码得到的tfidf结果:

for (int docNum = 0; docNum < ir.numDocs(); docNum++) {
            TermFreqVector tfv = ir.getTermFreqVector(docNum, "contents");
            if (tfv == null) {
                // ignore empty fields
                continue;
            }
            String[] tterms = tfv.getTerms();
            int termCount = tterms.length;
            int[] freqs = tfv.getTermFrequencies();
            for (int t = 0; t < termCount; t++) {
                double idf = ir.numDocs() / ir.docFreq(new Term("contents", tterms[t]));
                System.out.println(" " + tterms[t] + " " + freqs[t]*Math.log(idf));
            }
        }

此代码的输出是:

area 0.0
areola 5.877735781779639
ari 3.9318256327243257
art 1.6094379124341003
artifici 1.0986122886681098
assign …

我不明白CountVectorizer如何计算术语频率.我需要知道这一点,以便在max_df从语料库中过滤掉术语时,我可以为参数做出明智的选择.这是示例代码:

    import pandas as pd
    import numpy as np
    from sklearn.feature_extraction.text import CountVectorizer

    vectorizer = CountVectorizer(min_df = 1, max_df = 0.9)
    X = vectorizer.fit_transform(['afr bdf dssd','afr bdf c','afr'])
    word_freq_df = pd.DataFrame({'term': vectorizer.get_feature_names(), 'occurrences':np.asarray(X.sum(axis=0)).ravel().tolist()})
    word_freq_df['frequency'] = word_freq_df['occurrences']/np.sum(word_freq_df['occurrences'])
    print word_freq_df.sort('occurrences',ascending = False).head()

       occurrences  term  frequency
    0            3   afr   0.500000
    1            2   bdf   0.333333
    2            1  dssd   0.166667

似乎'afr'出现在我的语料库中的一半术语中,正如我期望通过查看语料库.然而,当我max_df = 0.8进入时CountVectorizer,术语'afr'被从我的语料库中过滤掉.到处玩,我发现在我的例子中使用coprus,CountVectorizer为'afr'分配了一个~0.833的频率.有人可以提供一个关于如何max_df计算enterts的术语频率的公式吗？

谢谢

我正在学习使用theano.我想通过计算其中每个元素的二进制TF-IDF来填充term-document矩阵(numpy稀疏矩阵):

import theano
import theano.tensor as T
import numpy as np
from time import perf_counter

def tfidf_gpu(appearance_in_documents,num_documents,document_words):
    start = perf_counter()
    APP = T.scalar('APP',dtype='int32')
    N = T.scalar('N',dtype='int32')
    SF = T.scalar('S',dtype='int32')
    F = (T.log(N)-T.log(APP)) / SF
    TFIDF = theano.function([N,APP,SF],F)
    ret = TFIDF(num_documents,appearance_in_documents,document_words)
    end = perf_counter()
    print("\nTFIDF_GPU ",end-start," secs.")
    return ret

def tfidf_cpu(appearance_in_documents,num_documents,document_words):
    start = perf_counter()
    tfidf = (np.log(num_documents)-np.log(appearance_in_documents))/document_words
    end = perf_counter()
    print("TFIDF_CPU ",end-start," secs.\n")
    return tfidf

但numpy版本比theano实现快得多:

Progress 1/43
TFIDF_GPU  0.05702276699594222  secs.
TFIDF_CPU  1.454801531508565e-05  secs.

Progress 2/43
TFIDF_GPU  0.023830442980397493  secs.
TFIDF_CPU  1.1073017958551645e-05 …

我想确保我了解TfidfVectorizer对象中的use_idf和sublinear_tf属性的作用。我已经研究了几天。我正在尝试对长度不同的文档进行分类，并使用当前的tf-idf进行功能选择。

我相信什么时候 use_idf=true算法将针对固有问题（使用TF）的偏见归一化，该术语的频率要高出X倍就不那么重要了。

利用tf*idf公式。然后sublinear_tf = true灌输1+log(tf)，以使对长文件和短文件的偏见正常化。

我正在处理对冗长文档（本质上属于一类）的内在偏见，这种规范化是否真的可以减少偏见？

如何确定语料库中文档的长度未集成到模型中？

我正在尝试验证是否在模型中应用了规范化。我试图提取语料库的归一化向量，所以我假设我可以对Tfidfvectorizer矩阵的每一行求和。但是总和大于1，我认为归一化的副本会将所有文档转换为0-1之间的范围。

vect = TfidfVectorizer(max_features=20000, strip_accents='unicode',
stop_words=stopwords,analyzer='word', use_idf=True, tokenizer=tokenizer, ngram_range=(1,2),sublinear_tf= True , norm='l2')

tfidf = vect.fit_transform(X_train)
# sum norm l2 documents
vect_sum = tfidf.sum(axis=1)

我正在使用 SciKit Learn 对大型数据集（+- 34.000 个文件）执行一些分析。现在我想知道。HashingVectorizer 旨在降低内存使用率。是否可以先将一堆文件转换为 HashingVectorizer 对象（使用 pickle.dump），然后将所有这些文件一起加载并将它们转换为 TfIdf 功能？这些特征可以从 HashingVectorizer 计算，因为计数被存储并且可以推导出文档的数量。我现在有以下几点：

for text in texts:
    vectorizer = HashingVectorizer(norm=None, non_negative=True)
    features = vectorizer.fit_transform([text])
    with open(path, 'wb') as handle:
        pickle.dump(features, handle)

然后，加载文件很简单：

data = []
for path in paths:
    with open(path, 'rb') as handle:
        data.append(pickle.load(handle))
tfidf = TfidfVectorizer()
tfidf.fit_transform(data)

但是，魔法不会发生。我怎样才能让魔法发生？

我有一张带有句子标题的图像表。给定一个新句子，我想根据新句子与存储的旧句子的接近程度，找到与之最匹配的图像。

我知道我可以将@@运算符与a一起使用，to_tsquery但tsquery可以接受特定单词作为查询。

一个问题是我不知道如何将给定的句子转换为有意义的查询。该句子可能带有标点符号和数字。

但是，我也觉得我需要某种余弦相似性，但我不知道如何从PostgresQL中获得它。我正在使用最新的GA版本，如果可以解决我的问题，很高兴使用开发版本。

我使用Spark MLlib来计算每个文档的所有术语'TFIDF的总和(每个文档由一行数据帧描述),我编写了以下代码:

from pyspark import SparkContext
from pyspark.sql import SQLContext, Row
from pyspark.mllib.feature import HashingTF
from pyspark.mllib.feature import IDF
from pyspark.mllib.linalg import SparseVector

sc = SparkContext() 
sqlContext = SQLContext(sc)

#SECTION 1
documents = sqlContext.createDataFrame([
    (0, "hello spark", "data1"),
    (1, "this is example", "data2"),
    (2, "spark is fast","data3"),
    (3, "hello world","data4")], ["doc_id", "doc_text", "another"])

#SECTION 2
documents.registerTempTable("doc_table")
textcolumn= sqlContext.sql("SELECT doc_text FROM doc_table")
doc_words= textcolumn.map(lambda d: d.doc_text).map(lambda t: t.split(" "))

#SECTION 3
hashingTF = HashingTF()
tf = hashingTF.transform(doc_words).cache()
idf = IDF().fit(tf)
tfidf …

Spark MLlib中的HashingTF中的numFeatures与文档（句子）中的实际术语数之间是否存在任何关系？

List<Row> data = Arrays.asList(
  RowFactory.create(0.0, "Hi I heard about Spark"),
  RowFactory.create(0.0, "I wish Java could use case classes"),
  RowFactory.create(1.0, "Logistic regression models are neat")
);
StructType schema = new StructType(new StructField[]{
  new StructField("label", DataTypes.DoubleType, false, Metadata.empty()),
  new StructField("sentence", DataTypes.StringType, false, Metadata.empty())
});
Dataset<Row> sentenceData = spark.createDataFrame(data, schema);

Tokenizer tokenizer = new Tokenizer().setInputCol("sentence").setOutputCol("words");
Dataset<Row> wordsData = tokenizer.transform(sentenceData);

int numFeatures = 20;
HashingTF hashingTF = new HashingTF()
  .setInputCol("words")
  .setOutputCol("rawFeatures")
  .setNumFeatures(numFeatures);

Dataset<Row> featurizedData = hashingTF.transform(wordsData);

如Spark Mllib文档中所述，HashingTF将每个句子转换为长度为numFeatures的特征向量。如果此处的每个文档（句子中包含成千上万个术语）会发生什么情况？numFeatures的值应该是多少？如何计算该值？

我有一组维基百科的文本.
使用tf-idf,我可以定义每个单词的权重.以上是代码:

import pandas as pd                                             
from sklearn.feature_extraction.text import TfidfVectorizer

wiki = pd.read_csv('people_wiki.csv')

tfidf_vectorizer = TfidfVectorizer(max_features= 1000000)
tfidf = tfidf_vectorizer.fit_transform(wiki['text'])

目标是查看tf-idf列中显示的权重:

文件'people_wiki.csv'在这里:

https://ufile.io/udg1y

我的数据集中有一个文本列，使用该列我想为所有存在的单词计算一个 IDF。scikit 中的 TFID 实现，如tfidfvectorize，直接为我提供 TFIDF 值，而不是仅提供单词 IDF。有没有办法让单词 IDF 给出一组文档？