Extraire les mots-clés les plus importants d'un ensemble de documents

Question

J'ai un ensemble de 3000 documents texte et je veux extraire 300 mots-clés (mots simples ou multiples).

J'ai essayé les approches ci-dessous -

RAKE: Il est une bibliothèque d'extraction à base de mot-clé Python et a lamentablement échoué.

Tf-Idf: Il m'a donné de bons mots-clés par document, mais nous ne sommes pas en mesure de les agréger et de trouver des mots-clés qui représentent l'ensemble du groupe de documents. En outre, il suffit de sélectionner les mots k les plus importants de chaque document en fonction du score Tf-Idf, n'est-ce pas?

Word2vec: J'ai été capable de faire des trucs sympas comme trouver des mots similaires mais je ne sais pas comment trouver des mots-clés importants qui l'utilisent.

Pouvez-vous suggérer une bonne approche (ou élaborer comment améliorer l'un de ces trois points ci-dessus) pour résoudre ce problème? Merci :)

Answer 1

est mieux pour vous de choisir manuellement ces 300 mots (ce n'est pas tant et une fois) - code écrit en Python 3

import os 
files = os.listdir() 
topWords = ["word1", "word2.... etc"] 
wordsCount = 0 
for file in files: 
     file_opened = open(file, "r") 
     lines = file_opened.read().split("\n") 
     for word in topWords: 
       if word in lines and wordsCount < 301: 
           print("I found %s" %word) 
           wordsCount += 1 
     #Check Again wordsCount to close first repetitive instruction 
     if wordsCount == 300: 
       break 

Answer 2

import os 
import operator 
from collections import defaultdict 
files = os.listdir() 
topWords = ["word1", "word2.... etc"] 
wordsCount = 0 
words = defaultdict(lambda: 0) 
for file in files: 
    open_file = open(file, "r") 
    for line in open_file.readlines(): 
     raw_words = line.split() 
     for word in raw_words: 
      words[word] += 1 
sorted_words = sorted(words.items(), key=operator.itemgetter(1)) 

prendre maintenant top 300 des mots triés , ils sont les mots que tu veux.

Answer 3

La manière la plus simple et la plus efficace d'appliquer l'implémentation de tf-idf pour les mots les plus importants. Si vous avez un mot d'arrêt, vous pouvez filtrer les mots d'arrêt avant d'appliquer ce code. J'espère que cela fonctionne pour toi.

import java.util.List; 

/** 
* Class to calculate TfIdf of term. 
* @author Mubin Shrestha 
*/ 
public class TfIdf { 

    /** 
    * Calculates the tf of term termToCheck 
    * @param totalterms : Array of all the words under processing document 
    * @param termToCheck : term of which tf is to be calculated. 
    * @return tf(term frequency) of term termToCheck 
    */ 
    public double tfCalculator(String[] totalterms, String termToCheck) { 
     double count = 0; //to count the overall occurrence of the term termToCheck 
     for (String s : totalterms) { 
      if (s.equalsIgnoreCase(termToCheck)) { 
       count++; 
      } 
     } 
     return count/totalterms.length; 
    } 

    /** 
    * Calculates idf of term termToCheck 
    * @param allTerms : all the terms of all the documents 
    * @param termToCheck 
    * @return idf(inverse document frequency) score 
    */ 
    public double idfCalculator(List allTerms, String termToCheck) { 
     double count = 0; 
     for (String[] ss : allTerms) { 
      for (String s : ss) { 
       if (s.equalsIgnoreCase(termToCheck)) { 
        count++; 
        break; 
       } 
      } 
     } 
     return 1 + Math.log(allTerms.size()/count); 
    } 
}