Algorithme d'extraction de mots clés et exemples d'application implémentés en Java

Algorithme d'extraction de mots-clés et exemples d'applications implémentés en Java

Avec l'avènement de l'ère Internet, les données textuelles massives ont causé de grandes difficultés à obtenir et à analyser. Par conséquent, il est nécessaire de mener des recherches sur les technologies de traitement du langage naturel telles que les mots-clés. extractions et applications. L'extraction de mots clés fait référence à l'extraction de mots ou d'expressions d'un morceau de texte qui représentent le mieux le sujet du texte, fournissant ainsi une prise en charge de tâches telles que la classification, la récupération et le regroupement de texte. Cet article présente plusieurs algorithmes d'extraction de mots clés et des exemples d'applications implémentés en Java.

1. Algorithme TF-IDF

TF-IDF est un algorithme couramment utilisé pour extraire des mots-clés du texte. Il calcule le poids des mots en fonction de leur fréquence d'occurrence dans le texte et de leur fréquence d'apparition dans l'ensemble du corpus. TF représente la fréquence d'un mot dans le texte courant, et IDF représente la fréquence inverse du document d'un mot dans l'ensemble du corpus. La formule de calcul est la suivante :

TF = (nombre d'occurrences d'un mot dans le texte) /. (nombre total de mots dans le texte)

IDF = log (nombre total de documents dans le corpus / nombre de documents contenant le mot)

TF-IDF = TF * IDF

Implémentation du code Java :

public Map<String, Double> tfIdf(List<String> docs) {
    Map<String, Integer> wordFreq = new HashMap<>();
    int totalWords = 0;
    for (String doc : docs) {
        String[] words = doc.split(" ");
        for (String word : words) {
            wordFreq.put(word, wordFreq.getOrDefault(word, 0) + 1);
            totalWords++;
        }
    }
    Map<String, Double> tfIdf = new HashMap<>();
    int docSize = docs.size();
    for (String word : wordFreq.keySet()) {
        double tf = (double) wordFreq.get(word) / totalWords;
        int docCount = 0;
        for (String doc : docs) {
            if (doc.contains(word)) {
                docCount++;
            }
        }
        double idf = Math.log((double) docSize / (docCount + 1));
        tfIdf.put(word, tf * idf);
    }
    return tfIdf;
}

2. Algorithme TextRank

TextRank est une extraction de mots-clés de texte et un algorithme basé sur un graphique pour l'extraction abstraite, qui utilise les relations de cooccurrence des mots pour construire un graphique et classe l'importance des mots dans le graphique comme étant identifiés. des mots-clés ou des phrases importantes. L'idée centrale de TextRank est l'algorithme PageRank, qui considère les relations de cooccurrence de mots comme des liens entre les pages, trie les mots et obtient des mots-clés dans le texte. Le processus de calcul de l'algorithme TextRank comprend les étapes suivantes :

1. Extraire des mots ou des phrases dans le texte ;
2. Établir un graphique de cooccurrence de mots et utiliser des relations de cooccurrence pour représenter les mots ; et calculez chaque valeur PageRank de chaque mot ;
4. Sélectionnez les mots les mieux classés comme mots-clés en fonction de la valeur PageRank.

Implémentation du code Java :

public List<String> textrank(List<String> docs, int numKeywords) {
    List<String> sentences = new ArrayList<>();
    for (String doc : docs) {
        sentences.addAll(Arrays.asList(doc.split("[。？！；]")));
    }
    List<String> words = new ArrayList<>();
    for (String sentence : sentences) {
        words.addAll(segment(sentence));
    }
    Map<String, Integer> wordFreq = new HashMap<>();
    Map<String, Set<String>> wordCooc = new HashMap<>();
    for (String word : words) {
        wordFreq.put(word, wordFreq.getOrDefault(word, 0) + 1);
        wordCooc.put(word, new HashSet<>());
    }
    for (String sentence : sentences) {
        List<String> senWords = segment(sentence);
        for (String w1 : senWords) {
            if (!wordFreq.containsKey(w1)) {
                continue;
            }
            for (String w2 : senWords) {
                if (!wordFreq.containsKey(w2)) {
                    continue;
                }
                if (!w1.equals(w2)) {
                    wordCooc.get(w1).add(w2);
                    wordCooc.get(w2).add(w1);
                }
            }
        }
    }
    Map<String, Double> wordScore = new HashMap<>();
    for (String word : words) {
        double score = 1.0;
        for (String coocWord : wordCooc.get(word)) {
            score += wordScore.getOrDefault(coocWord, 1.0) / wordCooc.get(coocWord).size();
        }
        wordScore.put(word, score);
    }
    List<Map.Entry<String, Double>> sortedWords =
            wordScore.entrySet().stream()
                     .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
                     .collect(Collectors.toList());
    List<String> keywords = new ArrayList<>();
    for (int i = 0; i < numKeywords && i < sortedWords.size(); i++) {
        keywords.add(sortedWords.get(i).getKey());
    }
    return keywords;
}

private List<String> segment(String text) {
    // 使用中文分词器分词
    // TODO
    return Arrays.asList(text.split(" "));
}

3. Modèle de sujet LDA

LDA est un modèle de sujet probabiliste qui peut traiter le texte comme un mélange de plusieurs sujets, effectuer une classification de sujets et une extraction de mots clés sur le texte. Le modèle thématique LDA traite les mots du texte comme une distribution de probabilité, où chaque mot peut être attribué à plusieurs sujets. Le modèle de sujet LDA doit spécifier le nombre de sujets et le nombre d'itérations, puis le résoudre via l'algorithme EM pour obtenir la distribution de mots de chaque sujet et la distribution de sujets de chaque texte.

Implémentation du code Java :

public List<String> lda(List<String> docs, int numTopics,
                        int numKeywords, int iterations) {
    List<List<String>> words = new ArrayList<>();
    for (String doc : docs) {
        words.add(segment(doc));
    }
    Dictionary dictionary = new Dictionary(words);
    Corpus corpus = new Corpus(dictionary);
    for (List<String> docWords : words) {
        Document doc = new Document(dictionary);
        for (String word : docWords) {
            doc.addWord(new Word(word));
        }
        corpus.addDocument(doc);
    }
    LdaGibbsSampler sampler = new LdaGibbsSampler(corpus, numTopics, 0.5, 0.1);
    sampler.gibbs(iterations);
    List<String> keywords = new ArrayList<>();
    for (int i = 0; i < numTopics; i++) {
        List<WordProbability> wordProbs = sampler.getSortedWordsByWeight(i);
        for (int j = 0; j < numKeywords && j < wordProbs.size(); j++) {
            keywords.add(wordProbs.get(j).getWord().getName());
        }
    }
    return keywords;
}

private List<String> segment(String text) {
    // 使用中文分词器分词
    // TODO
    return Arrays.asList(text.split(" "));
}

Exemples d'application

L'extraction de mots clés peut être appliquée à la classification de texte, à l'extraction de résumés, au classement des moteurs de recherche et à d'autres domaines. Voici des exemples d'application basés sur l'algorithme ci-dessus.

1. Classification des actualités

Étant donné le texte de certains reportages, l'algorithme TF-IDF peut être utilisé pour extraire les mots-clés de chaque texte, puis l'algorithme d'apprentissage automatique peut être utilisé pour la classification. Par exemple, un algorithme d'arbre de décision peut être utilisé pour classer les actualités, et des mots-clés peuvent être saisis dans l'arbre de décision en tant que fonctionnalités. L'effet de la classification peut être évalué par des méthodes telles que la validation croisée.

2. Extraction de résumé

À partir du texte d'un article, vous pouvez utiliser l'algorithme TextRank pour extraire les phrases clés et les combiner dans un résumé. L'extraction abstraite peut être appliquée à la synthèse automatique, à l'affichage des moteurs de recherche et à d'autres domaines.

3. Recherche de littérature scientifique et technologique

Dans la recherche de littérature scientifique et technologique, l'utilisateur saisit généralement un mot-clé ou une combinaison de mots-clés, puis le moteur de recherche calcule le degré de correspondance entre le document et le mot-clé via l'algorithme TF-IDF, et trie selon le degré correspondant. Permettez aux utilisateurs de trouver rapidement les documents pertinents. De plus, en combinaison avec le modèle de sujet LDA, les documents peuvent être classés en sujets et les mots-clés du sujet peuvent être utilisés comme entrée de recherche pour améliorer les résultats de recherche.

Conclusion

Cet article présente plusieurs algorithmes d'extraction de mots clés et exemples d'applications implémentés en Java. L'algorithme TF-IDF est l'un des algorithmes les plus couramment utilisés dans le traitement de texte. L'algorithme TextRank peut extraire des phrases clés et le modèle de sujet LDA peut classer les sujets de texte. Ces algorithmes peuvent être appliqués à la classification de documents, au résumé automatique, au classement dans les moteurs de recherche et à d'autres domaines, et ont de larges perspectives d'application.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!